Merge pull request #37 from ScrawnDotDev/feat/environments

Feat/environments

Author: SteakFisher

.env.example

@@ -4,11 +4,12 @@ DATABASE_URL="YOUR_NOT_SO_SECRET_DATABASE_URL_GOES_HERE"
 # Sentry
 SENTRY_DSN="" # Your Sentry DSN for error monitoring
 
-# Dodo Payments 
-DODO_PAYMENTS_API_KEY="" # Your Dodo Payments API key (from dashboard → Developer → API)
+# Dodo Payments
+DODO_PAYMENTS_LIVE_API_KEY="" # Your Dodo Payments API key for live/production mode
+DODO_PAYMENTS_TEST_API_KEY="" # Your Dodo Payments API key for test/sandbox mode
 DODO_PAYMENTS_PRODUCT_ID="" # Your Dodo product ID (prod_xxxxx)
 DODO_PAYMENTS_WEBHOOK_SECRET= # Webhook signing secret
-
+REDIRECT_URL=
 
 TEST_API_KEY=
 REDIS_URL=

src/factory/EventStorageAdapterFactory.ts

@@ -1,13 +1,14 @@
 import type { EventKind } from "../interface/event/Event.ts";
 import { ClickHouseAdapter } from "../storage/adapter/clickhouse/ClickHouseAdapter.ts";
+import { PostgresAdapter } from "../storage/adapter/postgres/postgres.js";
 
 export class StorageAdapterFactory {
   public static async getEventStorageAdapter(RequestType: EventKind) {
     switch (RequestType) {
       case "SDK_CALL":
       case "AI_TOKEN_USAGE":
       case "PAYMENT": {
-        return new ClickHouseAdapter();
+        return new PostgresAdapter();
       }
       default: {
         throw new Error(`Unknown event type: ${RequestType}`);

src/interface/storage/Storage.ts

@@ -62,14 +62,14 @@ export interface StorageAdapter {
 
   add(
     serialized: SerializedEvent,
-    apiKeyId?: string,
-    mode?: string
+    apiKeyId: string,
+    mode: "production" | "test"
   ): Promise<{ id: string } | void>;
   price(
     userID: UserId,
     event_type: EventKind,
     beforeTimestamp: DateTime,
-    mode?: string
+    mode: "production" | "test"
   ): Promise<number>;
   query(request: QueryRequest): Promise<QueryResponse>;
 }

src/routes/gRPC/payment/createCheckoutLink.ts

@@ -17,7 +17,6 @@ import type {
 import {
   getPaymentProviderConfig,
   createProviderCheckout,
-  getDodoClient,
   type CheckoutResult,
 } from "./paymentProvider.ts";
 import { StorageAdapterFactory } from "../../../factory";
@@ -26,7 +25,7 @@ import { apiKeyContextKey, type AuthContext } from "../../../context/auth";
 import { wideEventContextKey } from "../../../context/requestContext";
 import type { UserId } from "../../../config/identifiers";
 import { DateTime } from "luxon";
-import { handleAddSession } from "../../../storage/adapter/postgres/handlers";
+import { handleAddSession } from "../../../storage/db/postgres/helpers/sessions";
 import { type ContextUnaryCall } from "../../../interface/types/context.ts";
 
 export async function createCheckoutLink(
@@ -45,16 +44,20 @@ export async function createCheckoutLink(
 
     if (auth.role === "dashboard") {
       return callback?.(
-        AuthError.permissionDenied("Dashboard keys cannot create checkout links")
+        AuthError.permissionDenied(
+          "Dashboard keys cannot create checkout links"
+        )
       );
     }
 
-    if (auth.role === "test") {
+    if (!auth.mode) {
       return callback?.(
-        AuthError.permissionDenied("Test keys cannot create checkout links")
+        AuthError.permissionDenied("Auth mode not set on API key")
       );
     }
 
+    const mode = auth.mode;
+
     const config = getPaymentProviderConfig();
     const validatedData = validateRequest(req);
     wideEventBuilder?.setUser(validatedData.userId);
@@ -63,7 +66,7 @@ export async function createCheckoutLink(
     const custom_price = await calculatePrice(
       validatedData.userId,
       beforeTimestamp,
-      auth.mode!
+      mode
     );
     wideEventBuilder?.setPaymentContext({ priceAmount: custom_price });
 
@@ -72,21 +75,24 @@ export async function createCheckoutLink(
       custom_price,
       validatedData.userId,
       auth.apiKeyId,
-      beforeTimestamp
+      beforeTimestamp,
+      mode
     );
 
-    const sessionResult = await (handleAddSession as unknown as (
-      userId: UserId, sessionId: string, billedUpto: DateTime, mode?: string
-    ) => Promise<{ id: string }>)(
+    const sessionResult = await handleAddSession(
       validatedData.userId,
       checkoutResult.sessionId,
       beforeTimestamp,
-      auth.mode!
+      auth.apiKeyId,
+      mode,
+      checkoutResult.checkoutUrl
     );
     wideEventBuilder?.setPaymentContext({ sessionId: sessionResult.id });
 
+    const proxyUrl = `${process.env.APP_URL}/checkout/${sessionResult.id}`;
+
     const response = new CreateCheckoutLinkResponse();
-    response.setCheckoutlink(checkoutResult.checkoutUrl);
+    response.setCheckoutlink(proxyUrl);
     callback?.(null, response);
   } catch (error) {
     callback?.(error as Error);
@@ -109,7 +115,7 @@ function validateRequest(
 async function calculatePrice(
   userId: UserId,
   beforeTimestamp: DateTime,
-  mode: string
+  mode: "production" | "test"
 ): Promise<number> {
   const storageAdapter =
     await StorageAdapterFactory.getEventStorageAdapter("PAYMENT");
@@ -118,9 +124,12 @@ async function calculatePrice(
     throw PaymentError.storageAdapterFailed("Storage adapter not available");
   }
 
-  const price = await (storageAdapter as unknown as {
-    price: (userId: UserId, eventType: string, beforeTs: DateTime, mode?: string) => Promise<number>;
-  }).price(userId, "PAYMENT", beforeTimestamp, mode);
+  const price = await storageAdapter.price(
+    userId,
+    "PAYMENT",
+    beforeTimestamp,
+    mode
+  );
 
   if (typeof price !== "number" || isNaN(price) || price < 0) {
     throw PaymentError.priceCalculationFailed(
@@ -137,15 +146,16 @@ async function createCheckoutSession(
   customPrice: number,
   userId: string,
   apiKeyId: string,
-  beforeTimestamp: DateTime
+  beforeTimestamp: DateTime,
+  mode: "test" | "production"
 ): Promise<CheckoutResult> {
   const params: CheckoutParams = {
     customPrice,
     userId,
     apiKeyId,
   };
 
-  const checkoutResult = await createProviderCheckout(config, params);
+  const checkoutResult = await createProviderCheckout(config, params, mode);
 
   if (
     !checkoutResult.checkoutUrl ||

src/routes/gRPC/payment/paymentProvider.ts

@@ -1,22 +1,40 @@
 import DodoPayments from "dodopayments";
 import { PaymentError } from "../../../errors/payment";
 
-let client: DodoPayments | null = null;
+let liveClient: DodoPayments | null = null;
+let testClient: DodoPayments | null = null;
 
-export function getDodoClient(): DodoPayments {
-  if (!client) {
-    const apiKey = process.env.DODO_PAYMENTS_API_KEY;
+export function getDodoClient(mode?: "test" | "production"): DodoPayments {
+  if (!mode) {
+    mode = process.env.NODE_ENV === "production" ? "production" : "test";
+  }
+  if (mode === "production") {
+    if (!liveClient) {
+      const apiKey = process.env.DODO_PAYMENTS_LIVE_API_KEY;
+      if (!apiKey) {
+        throw PaymentError.missingApiKey();
+      }
+      liveClient = new DodoPayments({
+        bearerToken: apiKey,
+        environment: "live_mode",
+        webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_SIGNING_SECRET,
+      });
+    }
+    return liveClient;
+  }
+
+  if (!testClient) {
+    const apiKey = process.env.DODO_PAYMENTS_TEST_API_KEY;
     if (!apiKey) {
       throw PaymentError.missingApiKey();
     }
-    client = new DodoPayments({
+    testClient = new DodoPayments({
       bearerToken: apiKey,
-      environment:
-        process.env.NODE_ENV === "production" ? "live_mode" : "test_mode",
+      environment: "test_mode",
       webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_SIGNING_SECRET,
     });
   }
-  return client;
+  return testClient;
 }
 
 export interface PaymentProviderConfig {
@@ -37,7 +55,7 @@ export interface CheckoutResult {
 
 export function getPaymentProviderConfig(): PaymentProviderConfig {
   const productId = process.env.DODO_PAYMENTS_PRODUCT_ID;
-  const returnUrl = `${process.env.APP_URL}/checkout/success`;
+  const returnUrl = `${process.env.REDIRECT_URL}`;
 
   if (!productId) {
     throw PaymentError.missingProductId();
@@ -48,9 +66,10 @@ export function getPaymentProviderConfig(): PaymentProviderConfig {
 
 export async function createProviderCheckout(
   config: PaymentProviderConfig,
-  params: CheckoutParams
+  params: CheckoutParams,
+  mode: "test" | "production"
 ): Promise<CheckoutResult> {
-  const client = getDodoClient();
+  const client = getDodoClient(mode);
 
   const session = await client.checkoutSessions.create({
     product_cart: [

src/routes/http/checkoutRedirect.ts

@@ -0,0 +1,36 @@
+import type { FastifyRequest, FastifyReply } from "fastify";
+import { z } from "zod";
+import { getCheckoutUrl } from "../../storage/db/postgres/helpers/sessions";
+import { formatZodError } from "../../utils/formatZodError";
+
+const checkoutParamsSchema = z.object({
+  sessionId: z.string().uuid({ message: "Invalid session ID format" }),
+});
+
+export async function handleCheckoutRedirect(
+  request: FastifyRequest<{ Params: { sessionId: string } }>,
+  reply: FastifyReply
+): Promise<void> {
+  let sessionId: string;
+  try {
+    const parsed = checkoutParamsSchema.parse(request.params);
+    sessionId = parsed.sessionId;
+  } catch (error) {
+    const formatted = formatZodError(error, (msg) => ({
+      type: "ValidationError",
+      message: msg,
+      name: "ValidationError",
+    }));
+    reply.code(400);
+    return reply.send({ error: formatted.message });
+  }
+
+  const checkoutUrl = await getCheckoutUrl(sessionId);
+
+  if (!checkoutUrl) {
+    reply.code(404);
+    return reply.send({ error: "Checkout session not found" });
+  }
+
+  reply.code(302).redirect(checkoutUrl);
+}

src/routes/http/createdCheckout.ts

@@ -7,6 +7,7 @@ import { getDodoClient } from "../gRPC/payment/paymentProvider.ts";
 import { getPostgresDB } from "../../storage/db/postgres/db";
 import { usersTable, sessionsTable } from "../../storage/db/postgres/schema";
 import { eq } from "drizzle-orm";
+import { getSessionByCheckoutId } from "../../storage/db/postgres/helpers/sessions";
 
 
 const isDev = process.env.NODE_ENV !== "production";
@@ -85,20 +86,9 @@ export async function handleDodoWebhook(
       };
     }
 
-    const db = getPostgresDB();
+    const session = await getSessionByCheckoutId(checkout_session_id);
 
-    const sessions = await db
-      .select({
-        id: sessionsTable.id,
-        userId: sessionsTable.userId,
-        billed_upto: sessionsTable.billed_upto,
-        processed: sessionsTable.processed,
-      })
-      .from(sessionsTable)
-      .where(eq(sessionsTable.sessionId, checkout_session_id))
-      .limit(1);
-
-    if (sessions.length === 0 || !sessions[0]) {
+    if (!session) {
       builder.setError(404, {
         type: "NotFoundError",
         message: `Session not found for checkout_session_id: ${checkout_session_id}`,
@@ -109,7 +99,7 @@ export async function handleDodoWebhook(
       };
     }
 
-    const session = sessions[0];
+    const db = getPostgresDB();
 
     if (session.processed) {
       builder.setSuccess(200);
@@ -163,7 +153,7 @@ export async function handleDodoWebhook(
       const adapter =
         await StorageAdapterFactory.getEventStorageAdapter("PAYMENT");
 
-      await adapter.add(paymentEvent.serialize());
+      await adapter.add(paymentEvent.serialize(), session.apiKeyId, session.mode);
 
       builder.setSuccess(200);
       return {

src/servers/fastifyServer.ts

@@ -2,6 +2,7 @@ import { fastify } from "fastify";
 import fastifyRawBody from "fastify-raw-body";
 import { registerWebhookRoutes } from "../routes/http/registerWebhookRoutes.ts";
 import { registerApiRoutes } from "../routes/http/api/registerApiRoutes.ts";
+import { handleCheckoutRedirect } from "../routes/http/checkoutRedirect.ts";
 import { logger } from "../errors/logger.ts";
 
 export async function startFastifyServer(port: number, grpcPort: number): Promise<void> {
@@ -19,6 +20,10 @@ export async function startFastifyServer(port: number, grpcPort: number): Promis
     return "Hello World!";
   });
 
+  server.get<{ Params: { sessionId: string } }>("/checkout/:sessionId", async (request, reply) => {
+    await handleCheckoutRedirect(request, reply);
+  });
+
   await registerWebhookRoutes(server);
   await registerApiRoutes(server);