@abdssamie/adyen-payments 0.1.0

package/src/client/setup.test.ts

@@ -0,0 +1,26 @@
+/// <reference types="vite/client" />
+import { test } from "vitest";
+import { convexTest } from "convex-test";
+export const modules = import.meta.glob("./**/*.*s");
+
+import {
+  defineSchema,
+  type GenericSchema,
+  type SchemaDefinition,
+} from "convex/server";
+import { type ComponentApi } from "../component/_generated/component.js";
+import { componentsGeneric } from "convex/server";
+import { register } from "../test.js";
+
+export function initConvexTest<
+  Schema extends SchemaDefinition<GenericSchema, boolean>,
+>(schema?: Schema) {
+  const t = convexTest(schema ?? defineSchema({}), modules);
+  register(t);
+  return t;
+}
+export const components = componentsGeneric() as unknown as {
+  adyenPayments: ComponentApi;
+};
+
+test("setup", () => {});

package/src/client/webhooks.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test, vi, beforeEach } from "vitest";
+import type { HttpRouter } from "convex/server";
+import { registerRoutes, type ActionCtx } from "./index.js";
+import { components, initConvexTest } from "./setup.test.js";
+
+// Mock the Adyen SDK hmacValidator
+vi.mock("@adyen/api-library", () => {
+  class HmacValidatorMock {
+    validateHMAC = vi.fn().mockReturnValue(true);
+    validateBankingHMAC = vi.fn().mockReturnValue(true);
+  }
+  return {
+    Client: vi.fn(),
+    CheckoutAPI: vi.fn(),
+    hmacValidator: HmacValidatorMock,
+  };
+});
+
+describe("Adyen webhook processing tests", () => {
+  beforeEach(() => {
+    process.env.ADYEN_HMAC_KEY = "test_hmac_key";
+  });
+
+  test("route registration and authorisation success with tokenization", async () => {
+    const t = initConvexTest();
+
+    // Register routes with a mock HTTP router
+    const routes: Array<{ path: string; method: string; handler: (...args: any[]) => any }> = [];
+    const mockHttp = {
+      route: (r: { path: string; method: string; handler: (...args: any[]) => any }) => {
+        routes.push(r);
+      },
+    } as unknown as HttpRouter;
+
+    const onNotificationSpy = vi.fn();
+    const customAuthorisationSpy = vi.fn();
+
+    registerRoutes(mockHttp, components.adyenPayments, {
+      webhookPath: "/adyen/webhooks",
+      events: {
+        AUTHORISATION: customAuthorisationSpy,
+      },
+      onNotification: onNotificationSpy,
+    });
+
+    expect(routes).toHaveLength(1);
+    expect(routes[0].path).toBe("/adyen/webhooks");
+    expect(routes[0].method).toBe("POST");
+
+    const handler = routes[0].handler;
+
+    // Simulate an AUTHORISATION notification containing token details
+    const request = new Request("https://example.com/adyen/webhooks", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        notificationItems: [
+          {
+            NotificationRequestItem: {
+              eventCode: "AUTHORISATION",
+              pspReference: "psp_auth_1",
+              merchantReference: "order_123",
+              success: "true",
+              amount: { value: 5000, currency: "USD" },
+              shopperReference: "user_abc",
+              paymentMethod: "visa",
+              additionalData: {
+                hmacSignature: "mock_signature",
+                "recurring.recurringDetailReference": "token_xyz",
+                cardSummary: "1111",
+                expiryDate: "12/2030",
+                paymentMethod: "visa",
+              },
+            },
+          },
+        ],
+      }),
+    });
+
+    const response = await handler(t as unknown as ActionCtx, request);
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe("[accepted]");
+
+    // Verify DB states: payment transaction was recorded
+    const payment = await t.query(components.adyenPayments.public.getPayment, {
+      pspReference: "psp_auth_1",
+    });
+    expect(payment).not.toBeNull();
+    expect(payment!.status).toBe("authorised");
+    expect(payment!.amount).toBe(5000);
+    expect(payment!.shopperReference).toBe("user_abc");
+
+    // Verify DB states: payment method card was tokenized
+    const methods = await t.query(components.adyenPayments.public.listPaymentMethods, {
+      shopperReference: "user_abc",
+    });
+    expect(methods).toHaveLength(1);
+    expect(methods[0].recurringDetailReference).toBe("token_xyz");
+    expect(methods[0].cardLast4).toBe("1111");
+    expect(methods[0].cardExpiryMonth).toBe("12");
+    expect(methods[0].cardExpiryYear).toBe("2030");
+
+    // Verify custom handlers were triggered
+    expect(onNotificationSpy).toHaveBeenCalledOnce();
+    expect(customAuthorisationSpy).toHaveBeenCalledOnce();
+  });
+
+  test("modification notifications (CAPTURE, REFUND, CANCEL)", async () => {
+    const t = initConvexTest();
+
+    // Seed an authorised payment in the database
+    await t.mutation(components.adyenPayments.private.recordPayment, {
+      pspReference: "psp_auth_2",
+      merchantReference: "order_456",
+      amount: 1000,
+      currency: "EUR",
+      status: "authorised",
+      shopperReference: "user_def",
+    });
+
+    const routes: Array<{ path: string; method: string; handler: (...args: any[]) => any }> = [];
+    const mockHttp = {
+      route: (r: { path: string; method: string; handler: (...args: any[]) => any }) => {
+        routes.push(r);
+      },
+    } as unknown as HttpRouter;
+    registerRoutes(mockHttp, components.adyenPayments);
+    const handler = routes[0].handler;
+
+    // 1. CAPTURE webhook
+    const captureRequest = new Request("https://example.com/adyen/webhooks", {
+      method: "POST",
+      body: JSON.stringify({
+        notificationItems: [
+          {
+            NotificationRequestItem: {
+              eventCode: "CAPTURE",
+              pspReference: "psp_cap_2",
+              originalReference: "psp_auth_2",
+              merchantReference: "order_456",
+              success: "true",
+              amount: { value: 1000, currency: "EUR" },
+            },
+          },
+        ],
+      }),
+    });
+    await handler(t as unknown as ActionCtx, captureRequest);
+
+    const capturedPayment = await t.query(components.adyenPayments.public.getPayment, {
+      pspReference: "psp_auth_2",
+    });
+    expect(capturedPayment!.status).toBe("captured");
+
+    // 2. REFUND webhook
+    const refundRequest = new Request("https://example.com/adyen/webhooks", {
+      method: "POST",
+      body: JSON.stringify({
+        notificationItems: [
+          {
+            NotificationRequestItem: {
+              eventCode: "REFUND",
+              pspReference: "psp_ref_2",
+              originalReference: "psp_auth_2",
+              merchantReference: "order_456",
+              success: "true",
+              amount: { value: 1000, currency: "EUR" },
+            },
+          },
+        ],
+      }),
+    });
+    await handler(t as unknown as ActionCtx, refundRequest);
+
+    const refundedPayment = await t.query(components.adyenPayments.public.getPayment, {
+      pspReference: "psp_auth_2",
+    });
+    expect(refundedPayment!.status).toBe("refunded");
+  });
+});

package/src/component/_generated/api.ts

@@ -0,0 +1,52 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as private_ from "../private.js";
+import type * as public_ from "../public.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+import { anyApi, componentsGeneric } from "convex/server";
+
+const fullApi: ApiFromModules<{
+  private: typeof private_;
+  public: typeof public_;
+}> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
+
+export const components = componentsGeneric() as unknown as {};

package/src/component/_generated/component.ts

@@ -0,0 +1,293 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type { FunctionReference } from "convex/server";
+
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> =
+  {
+    private: {
+      insertCheckoutSession: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          amount: number;
+          autoCapture?: boolean;
+          currency: string;
+          merchantReference: string;
+          sessionData: string;
+          sessionId: string;
+          shopperReference?: string;
+          url?: string;
+        },
+        null,
+        Name
+      >;
+      insertPaymentMethod: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          cardExpiryMonth?: string;
+          cardExpiryYear?: string;
+          cardLast4?: string;
+          metadata?: any;
+          recurringDetailReference: string;
+          shopperReference: string;
+          variant: string;
+        },
+        null,
+        Name
+      >;
+      recordPayment: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          amount: number;
+          currency: string;
+          merchantReference: string;
+          metadata?: any;
+          orgId?: string;
+          originalReference?: string;
+          paymentMethod?: string;
+          pspReference: string;
+          shopperReference?: string;
+          status: string;
+          userId?: string;
+        },
+        null,
+        Name
+      >;
+      syncPaymentMethods: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          paymentMethods: Array<{
+            cardExpiryMonth?: string;
+            cardExpiryYear?: string;
+            cardLast4?: string;
+            metadata?: any;
+            recurringDetailReference: string;
+            variant: string;
+          }>;
+          shopperReference: string;
+        },
+        null,
+        Name
+      >;
+      updateCheckoutSessionStatus: FunctionReference<
+        "mutation",
+        "internal",
+        { merchantReference: string; status: string },
+        null,
+        Name
+      >;
+      updatePaymentStatus: FunctionReference<
+        "mutation",
+        "internal",
+        { originalReference?: string; pspReference: string; status: string },
+        null,
+        Name
+      >;
+    };
+    public: {
+      createOrUpdateShopper: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          email?: string;
+          metadata?: any;
+          name?: string;
+          shopperReference: string;
+          userId?: string;
+        },
+        string,
+        Name
+      >;
+      getCheckoutSession: FunctionReference<
+        "query",
+        "internal",
+        { sessionId: string },
+        {
+          amount: number;
+          autoCapture?: boolean;
+          currency: string;
+          merchantReference: string;
+          sessionData: string;
+          sessionId: string;
+          shopperReference?: string;
+          status: string;
+          url?: string;
+        } | null,
+        Name
+      >;
+      getCheckoutSessionByMerchantReference: FunctionReference<
+        "query",
+        "internal",
+        { merchantReference: string },
+        {
+          amount: number;
+          autoCapture?: boolean;
+          currency: string;
+          merchantReference: string;
+          sessionData: string;
+          sessionId: string;
+          shopperReference?: string;
+          status: string;
+          url?: string;
+        } | null,
+        Name
+      >;
+      getPayment: FunctionReference<
+        "query",
+        "internal",
+        { pspReference: string },
+        {
+          amount: number;
+          created: number;
+          currency: string;
+          merchantReference: string;
+          metadata?: any;
+          orgId?: string;
+          originalReference?: string;
+          paymentMethod?: string;
+          pspReference: string;
+          shopperReference?: string;
+          status: string;
+          userId?: string;
+        } | null,
+        Name
+      >;
+      getShopper: FunctionReference<
+        "query",
+        "internal",
+        { shopperReference: string },
+        {
+          email?: string;
+          metadata?: any;
+          name?: string;
+          shopperReference: string;
+          userId?: string;
+        } | null,
+        Name
+      >;
+      getShopperByEmail: FunctionReference<
+        "query",
+        "internal",
+        { email: string },
+        {
+          email?: string;
+          metadata?: any;
+          name?: string;
+          shopperReference: string;
+          userId?: string;
+        } | null,
+        Name
+      >;
+      getShopperByUserId: FunctionReference<
+        "query",
+        "internal",
+        { userId: string },
+        {
+          email?: string;
+          metadata?: any;
+          name?: string;
+          shopperReference: string;
+          userId?: string;
+        } | null,
+        Name
+      >;
+      listPaymentMethods: FunctionReference<
+        "query",
+        "internal",
+        { shopperReference: string },
+        Array<{
+          cardExpiryMonth?: string;
+          cardExpiryYear?: string;
+          cardLast4?: string;
+          metadata?: any;
+          recurringDetailReference: string;
+          shopperReference: string;
+          status: string;
+          variant: string;
+        }>,
+        Name
+      >;
+      listPayments: FunctionReference<
+        "query",
+        "internal",
+        { shopperReference: string },
+        Array<{
+          amount: number;
+          created: number;
+          currency: string;
+          merchantReference: string;
+          metadata?: any;
+          orgId?: string;
+          originalReference?: string;
+          paymentMethod?: string;
+          pspReference: string;
+          shopperReference?: string;
+          status: string;
+          userId?: string;
+        }>,
+        Name
+      >;
+      listPaymentsByOrgId: FunctionReference<
+        "query",
+        "internal",
+        { orgId: string },
+        Array<{
+          amount: number;
+          created: number;
+          currency: string;
+          merchantReference: string;
+          metadata?: any;
+          orgId?: string;
+          originalReference?: string;
+          paymentMethod?: string;
+          pspReference: string;
+          shopperReference?: string;
+          status: string;
+          userId?: string;
+        }>,
+        Name
+      >;
+      listPaymentsByUserId: FunctionReference<
+        "query",
+        "internal",
+        { userId: string },
+        Array<{
+          amount: number;
+          created: number;
+          currency: string;
+          merchantReference: string;
+          metadata?: any;
+          orgId?: string;
+          originalReference?: string;
+          paymentMethod?: string;
+          pspReference: string;
+          shopperReference?: string;
+          status: string;
+          userId?: string;
+        }>,
+        Name
+      >;
+    };
+  };

package/src/component/_generated/dataModel.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;