Webhook responses for Stripe use-cases

apps/stripe/src/__tests__/mocks/app-config-repo.ts

@@ -4,15 +4,14 @@ import { vi } from "vitest";
 import { mockStripeWebhookSecret } from "@/__tests__/mocks/stripe-webhook-secret";
 import { AppConfigRepo } from "@/modules/app-config/app-config-repo";
 import { StripeConfig } from "@/modules/app-config/stripe-config";
-import { StripePublishableKey } from "@/modules/stripe/stripe-publishable-key";
 import { StripeRestrictedKey } from "@/modules/stripe/stripe-restricted-key";
 
+import { stripePublishableKey } from "./stripe-publishable-key";
+
 const mockedStripeConfig = StripeConfig.create({
   id: "config-id",
   name: "config-name",
-  publishableKey: StripePublishableKey.create({
-    publishableKey: "pk_live_1",
-  })._unsafeUnwrap(),
+  publishableKey: stripePublishableKey,
   restrictedKey: StripeRestrictedKey.create({ restrictedKey: "rk_live_1" })._unsafeUnwrap(),
   webhookSecret: mockStripeWebhookSecret,
 })._unsafeUnwrap();

apps/stripe/src/__tests__/mocks/stripe-publishable-key.ts

@@ -0,0 +1,5 @@
+import { StripePublishableKey } from "@/modules/stripe/stripe-publishable-key";
+
+export const stripePublishableKey = StripePublishableKey.create({
+  publishableKey: "pk_live_1",
+})._unsafeUnwrap();

apps/stripe/src/app/api/saleor/payment-gateway-initialize-session/route.ts

@@ -2,79 +2,53 @@
 import { compose } from "@saleor/apps-shared/compose";
 import { captureException } from "@sentry/nextjs";
 
-import { InitializeStripeSessionUseCase } from "@/app/api/saleor/payment-gateway-initialize-session/use-case";
-import { paymentGatewayInitializeSessionWebhookDefinition } from "@/app/api/saleor/payment-gateway-initialize-session/webhook-definition";
 import { appConfigPersistence } from "@/lib/app-config-persistence";
-import { UseCaseGetConfigError, UseCaseMissingConfigError } from "@/lib/errors";
 import { withLoggerContext } from "@/lib/logger-context";
 import { SaleorApiUrl } from "@/modules/saleor/saleor-api-url";
+import {
+  MalformedRequestResponse,
+  UnhandledErrorResponse,
+} from "@/modules/saleor/saleor-webhook-responses";
 
-const useCase = new InitializeStripeSessionUseCase({
+import { PaymentGatewayInitializeSessionUseCase } from "./use-case";
+import { paymentGatewayInitializeSessionWebhookDefinition } from "./webhook-definition";
+
+const useCase = new PaymentGatewayInitializeSessionUseCase({
   appConfigRepo: appConfigPersistence,
 });
 
 const handler = paymentGatewayInitializeSessionWebhookDefinition.createHandler(async (req, ctx) => {
-  /*
-   * todo create config repo
-   * todo: should we pass auth data to execute? likely yes
-   */
+  try {
+    const saleorApiUrlResult = SaleorApiUrl.create({ url: ctx.authData.saleorApiUrl });
 
-  const saleorApiUrlResult = SaleorApiUrl.create({ url: ctx.authData.saleorApiUrl });
+    if (saleorApiUrlResult.isErr()) {
+      const response = new MalformedRequestResponse();
 
-  if (saleorApiUrlResult.isErr()) {
-    // TODO: maybe we should throw here?
-    return Response.json(
-      {
-        message: "Invalid Saleor API URL",
-      },
-      {
-        status: 400,
-      },
-    );
-  }
+      captureException(saleorApiUrlResult.error);
 
-  const result = await useCase.execute({
-    channelId: ctx.payload.sourceObject.channel.id,
-    appId: ctx.authData.appId,
-    saleorApiUrl: saleorApiUrlResult.value,
-  });
+      return response.getResponse();
+    }
 
-  return result.match(
-    (result) => {
-      return Response.json(result);
-    },
-    (err) => {
-      switch (err["constructor"]) {
-        case UseCaseMissingConfigError:
-        case UseCaseGetConfigError:
-          return Response.json(
-            {
-              message: err.httpMessage,
-            },
-            {
-              status: err.httpStatusCode,
-            },
-          );
+    const result = await useCase.execute({
+      channelId: ctx.payload.sourceObject.channel.id,
+      appId: ctx.authData.appId,
+      saleorApiUrl: saleorApiUrlResult.value,
+    });
 
-        default: {
-          captureException(
-            new Error("Unhandled error in GatewayInitializeSession", {
-              cause: err,
-            }),
-          );
+    return result.match(
+      (result) => {
+        return result.getResponse();
+      },
+      (err) => {
+        return err.getResponse();
+      },
+    );
+  } catch (error) {
+    captureException(error);
+    const response = new UnhandledErrorResponse();
 
-          return Response.json(
-            {
-              message: "Unhandled error",
-            },
-            {
-              status: 500,
-            },
-          );
-        }
-      }
-    },
-  );
+    return response.getResponse();
+  }
 });
 
 export const POST = compose(withLoggerContext, withSpanAttributesAppRouter)(handler);

apps/stripe/src/app/api/saleor/payment-gateway-initialize-session/use-case-response.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+
+import { stripePublishableKey } from "@/__tests__/mocks/stripe-publishable-key";
+
+import { PaymentGatewayInitializeSessionUseCaseResponses } from "./use-case-response";
+
+describe("PaymentGatewayInitializeSessionUseCaseResponses", () => {
+  describe("Success", () => {
+    it("should return fetch API response with status code and message", async () => {
+      const successResponse = new PaymentGatewayInitializeSessionUseCaseResponses.Success({
+        pk: stripePublishableKey,
+      });
+      const fetchReponse = successResponse.getResponse();
+
+      expect(fetchReponse.status).toBe(200);
+      expect(await fetchReponse.json()).toMatchInlineSnapshot(`
+        {
+          "data": {
+            "stripePublishableKey": "pk_live_1",
+          },
+        }
+      `);
+    });
+  });
+});

apps/stripe/src/app/api/saleor/payment-gateway-initialize-session/use-case-response.ts

@@ -0,0 +1,36 @@
+import { buildSyncWebhookResponsePayload } from "@saleor/app-sdk/handlers/shared";
+import { z } from "zod";
+
+import { SuccessWebhookResponse } from "@/modules/saleor/saleor-webhook-responses";
+import { StripePublishableKey } from "@/modules/stripe/stripe-publishable-key";
+
+class Success extends SuccessWebhookResponse {
+  pk: StripePublishableKey;
+
+  private static ResponseDataSchema = z.object({
+    stripePublishableKey: z.string(),
+  });
+
+  constructor(args: { pk: StripePublishableKey }) {
+    super();
+    this.pk = args.pk;
+  }
+
+  getResponse() {
+    const typeSafeResponse = buildSyncWebhookResponsePayload<"PAYMENT_GATEWAY_INITIALIZE_SESSION">({
+      data: Success.ResponseDataSchema.parse({
+        stripePublishableKey: this.pk.keyValue,
+      }),
+    });
+
+    return Response.json(typeSafeResponse, { status: this.statusCode });
+  }
+}
+
+export const PaymentGatewayInitializeSessionUseCaseResponses = {
+  Success,
+};
+
+export type PaymentGatewayInitializeSessionUseCaseResponsesType = InstanceType<
+  (typeof PaymentGatewayInitializeSessionUseCaseResponses)[keyof typeof PaymentGatewayInitializeSessionUseCaseResponses]
+>;

apps/stripe/src/app/api/saleor/payment-gateway-initialize-session/use-case.test.ts

@@ -4,12 +4,15 @@ import { describe, expect, it, vi } from "vitest";
 import { mockedAppConfigRepo } from "@/__tests__/mocks/app-config-repo";
 import { mockedSaleorAppId, mockedSaleorChannelId } from "@/__tests__/mocks/constants";
 import { mockedSaleorApiUrl } from "@/__tests__/mocks/saleor-api-url";
-import { InitializeStripeSessionUseCase } from "@/app/api/saleor/payment-gateway-initialize-session/use-case";
-import { UseCaseMissingConfigError } from "@/lib/errors";
+import { stripePublishableKey } from "@/__tests__/mocks/stripe-publishable-key";
+import { PaymentGatewayInitializeSessionUseCaseResponses } from "@/app/api/saleor/payment-gateway-initialize-session/use-case-response";
+import { AppIsNotConfiguredResponse } from "@/modules/saleor/saleor-webhook-responses";
 
-describe("InitializeStripeSessionUseCase", () => {
-  it('Returns publishable key within "data" object if found in configuration', async () => {
-    const uc = new InitializeStripeSessionUseCase({
+import { PaymentGatewayInitializeSessionUseCase } from "./use-case";
+
+describe("PaymentGatewayInitializeSessionUseCase", () => {
+  it('Returns Success response with publishable key within "data" object if found in configuration', async () => {
+    const uc = new PaymentGatewayInitializeSessionUseCase({
       appConfigRepo: mockedAppConfigRepo,
     });
 
@@ -19,19 +22,25 @@ describe("InitializeStripeSessionUseCase", () => {
       appId: mockedSaleorAppId,
     });
 
-    expect(responsePayload._unsafeUnwrap()).toStrictEqual({
+    expect(responsePayload._unsafeUnwrap()).toBeInstanceOf(
+      PaymentGatewayInitializeSessionUseCaseResponses.Success,
+    );
+
+    const jsonResponse = await responsePayload._unsafeUnwrap().getResponse().json();
+
+    expect(jsonResponse).toStrictEqual({
       data: {
-        stripePublishableKey: "pk_live_1",
+        stripePublishableKey: stripePublishableKey.keyValue,
       },
     });
   });
 
-  it("Returns AppNotConfiguredError if config not found for specified channel", async () => {
+  it("Returns MissingConfigErrorResponse if config not found for specified channel", async () => {
     const spy = vi
       .spyOn(mockedAppConfigRepo, "getStripeConfig")
       .mockImplementationOnce(async () => ok(null));
 
-    const uc = new InitializeStripeSessionUseCase({
+    const uc = new PaymentGatewayInitializeSessionUseCase({
       appConfigRepo: mockedAppConfigRepo,
     });
 
@@ -43,7 +52,7 @@ describe("InitializeStripeSessionUseCase", () => {
 
     const err = responsePayload._unsafeUnwrapErr();
 
-    expect(err).toBeInstanceOf(UseCaseMissingConfigError);
+    expect(err).toBeInstanceOf(AppIsNotConfiguredResponse);
     expect(spy).toHaveBeenCalledOnce();
   });
 });