@abdssamie/adyen-payments 0.1.0

package/src/component/public.ts

@@ -0,0 +1,229 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+import schema from "./schema.js";
+
+// Reusable validators that omit system fields (_id, _creationTime)
+const shopperValidator = schema.tables.shoppers.validator;
+const paymentMethodValidator = schema.tables.payment_methods.validator;
+const paymentValidator = schema.tables.payments.validator;
+const checkoutSessionValidator = schema.tables.checkout_sessions.validator;
+
+// ============================================================================
+// PUBLIC QUERIES
+// ============================================================================
+
+/**
+ * Get a shopper by their shopperReference.
+ */
+export const getShopper = query({
+  args: { shopperReference: v.string() },
+  returns: v.union(shopperValidator, v.null()),
+  handler: async (ctx, args) => {
+    const shopper = await ctx.db
+      .query("shoppers")
+      .withIndex("by_shopper_reference", (q) =>
+        q.eq("shopperReference", args.shopperReference)
+      )
+      .unique();
+    if (!shopper) return null;
+    const { _id, _creationTime, ...data } = shopper;
+    return data;
+  },
+});
+
+/**
+ * Get a shopper by their email address.
+ */
+export const getShopperByEmail = query({
+  args: { email: v.string() },
+  returns: v.union(shopperValidator, v.null()),
+  handler: async (ctx, args) => {
+    const shopper = await ctx.db
+      .query("shoppers")
+      .withIndex("by_email", (q) => q.eq("email", args.email))
+      .first();
+    if (!shopper) return null;
+    const { _id, _creationTime, ...data } = shopper;
+    return data;
+  },
+});
+
+/**
+ * Get a shopper by their user ID.
+ */
+export const getShopperByUserId = query({
+  args: { userId: v.string() },
+  returns: v.union(shopperValidator, v.null()),
+  handler: async (ctx, args) => {
+    const shopper = await ctx.db
+      .query("shoppers")
+      .withIndex("by_user_id", (q) => q.eq("userId", args.userId))
+      .first();
+    if (!shopper) return null;
+    const { _id, _creationTime, ...data } = shopper;
+    return data;
+  },
+});
+
+/**
+ * Get a payment transaction by its PSP reference.
+ */
+export const getPayment = query({
+  args: { pspReference: v.string() },
+  returns: v.union(paymentValidator, v.null()),
+  handler: async (ctx, args) => {
+    const payment = await ctx.db
+      .query("payments")
+      .withIndex("by_psp_reference", (q) =>
+        q.eq("pspReference", args.pspReference)
+      )
+      .unique();
+    if (!payment) return null;
+    const { _id, _creationTime, ...data } = payment;
+    return data;
+  },
+});
+
+/**
+ * List all payments for a shopper.
+ */
+export const listPayments = query({
+  args: { shopperReference: v.string() },
+  returns: v.array(paymentValidator),
+  handler: async (ctx, args) => {
+    const payments = await ctx.db
+      .query("payments")
+      .withIndex("by_shopper_reference", (q) =>
+        q.eq("shopperReference", args.shopperReference)
+      )
+      .collect();
+    return payments.map(({ _id, _creationTime, ...data }) => data);
+  },
+});
+
+/**
+ * List all payments for an organization ID.
+ */
+export const listPaymentsByOrgId = query({
+  args: { orgId: v.string() },
+  returns: v.array(paymentValidator),
+  handler: async (ctx, args) => {
+    const payments = await ctx.db
+      .query("payments")
+      .withIndex("by_org_id", (q) => q.eq("orgId", args.orgId))
+      .collect();
+    return payments.map(({ _id, _creationTime, ...data }) => data);
+  },
+});
+
+/**
+ * List all payments for a user ID.
+ */
+export const listPaymentsByUserId = query({
+  args: { userId: v.string() },
+  returns: v.array(paymentValidator),
+  handler: async (ctx, args) => {
+    const payments = await ctx.db
+      .query("payments")
+      .withIndex("by_user_id", (q) => q.eq("userId", args.userId))
+      .collect();
+    return payments.map(({ _id, _creationTime, ...data }) => data);
+  },
+});
+
+/**
+ * List stored payment methods for a shopper.
+ */
+export const listPaymentMethods = query({
+  args: { shopperReference: v.string() },
+  returns: v.array(paymentMethodValidator),
+  handler: async (ctx, args) => {
+    const methods = await ctx.db
+      .query("payment_methods")
+      .withIndex("by_shopper_reference", (q) =>
+        q.eq("shopperReference", args.shopperReference)
+      )
+      .collect();
+    return methods.map(({ _id, _creationTime, ...data }) => data);
+  },
+});
+
+/**
+ * Get a checkout session by its session ID.
+ */
+export const getCheckoutSession = query({
+  args: { sessionId: v.string() },
+  returns: v.union(checkoutSessionValidator, v.null()),
+  handler: async (ctx, args) => {
+    const session = await ctx.db
+      .query("checkout_sessions")
+      .withIndex("by_session_id", (q) => q.eq("sessionId", args.sessionId))
+      .unique();
+    if (!session) return null;
+    const { _id, _creationTime, ...data } = session;
+    return data;
+  },
+});
+
+// ============================================================================
+// PUBLIC MUTATIONS
+// ============================================================================
+
+/**
+ * Create or update a shopper mapping with optional metadata.
+ */
+export const createOrUpdateShopper = mutation({
+  args: {
+    shopperReference: v.string(),
+    email: v.optional(v.string()),
+    name: v.optional(v.string()),
+    userId: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+  },
+  returns: v.string(),
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("shoppers")
+      .withIndex("by_shopper_reference", (q) =>
+        q.eq("shopperReference", args.shopperReference)
+      )
+      .unique();
+
+    if (existing) {
+      await ctx.db.patch("shoppers", existing._id, {
+        ...(args.email !== undefined && { email: args.email }),
+        ...(args.name !== undefined && { name: args.name }),
+        ...(args.userId !== undefined && { userId: args.userId }),
+        ...(args.metadata !== undefined && { metadata: args.metadata }),
+      });
+    } else {
+      await ctx.db.insert("shoppers", {
+        shopperReference: args.shopperReference,
+        email: args.email,
+        name: args.name,
+        userId: args.userId,
+        metadata: args.metadata,
+      });
+    }
+    return args.shopperReference;
+  },
+});
+
+/**
+ * Get a checkout session by its merchantReference.
+ */
+export const getCheckoutSessionByMerchantReference = query({
+  args: { merchantReference: v.string() },
+  returns: v.union(checkoutSessionValidator, v.null()),
+  handler: async (ctx, args) => {
+    const session = await ctx.db
+      .query("checkout_sessions")
+      .withIndex("by_merchant_reference", (q) =>
+        q.eq("merchantReference", args.merchantReference)
+      )
+      .unique();
+    if (!session) return null;
+    const { _id, _creationTime, ...data } = session;
+    return data;
+  },
+});

package/src/component/schema.ts

@@ -0,0 +1,67 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  shoppers: defineTable({
+    shopperReference: v.string(), // Unique key defined by the merchant (e.g. userId)
+    email: v.optional(v.string()),
+    name: v.optional(v.string()),
+    userId: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+  })
+    .index("by_shopper_reference", ["shopperReference"])
+    .index("by_email", ["email"])
+    .index("by_user_id", ["userId"]),
+
+  // Tokenized payment instruments (stored details)
+  payment_methods: defineTable({
+    shopperReference: v.string(),
+    recurringDetailReference: v.string(), // Token used for recurring charges
+    variant: v.string(), // e.g. "visa", "mc", "ideal"
+    cardLast4: v.optional(v.string()),
+    cardExpiryMonth: v.optional(v.string()),
+    cardExpiryYear: v.optional(v.string()),
+    status: v.string(), // "active" or "disabled"
+    metadata: v.optional(v.any()),
+  })
+    .index("by_recurring_detail_reference", ["recurringDetailReference"])
+    .index("by_shopper_reference", ["shopperReference"]),
+
+  // Transaction history synced from webhooks
+  payments: defineTable({
+    pspReference: v.string(), // Adyen transaction ID
+    originalReference: v.optional(v.string()), // For refunds/captures referencing the auth
+    shopperReference: v.optional(v.string()),
+    merchantReference: v.string(), // App's order reference
+    amount: v.number(), // Value in minor units (e.g. cents)
+    currency: v.string(),
+    status: v.string(), // "authorised", "captured", "refused", "cancelled", "refunded"
+    paymentMethod: v.optional(v.string()),
+    created: v.number(),
+    userId: v.optional(v.string()),
+    orgId: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+  })
+    .index("by_psp_reference", ["pspReference"])
+    .index("by_shopper_reference", ["shopperReference"])
+    .index("by_merchant_reference", ["merchantReference"])
+    .index("by_user_id", ["userId"])
+    .index("by_org_id", ["orgId"]),
+
+  // Checkout sessions for payment initialization
+  checkout_sessions: defineTable({
+    sessionId: v.string(),
+    sessionData: v.string(), // Frontend config string
+    shopperReference: v.optional(v.string()),
+    merchantReference: v.string(),
+    status: v.string(), // "active" or "completed"
+    amount: v.number(),
+    currency: v.string(),
+    url: v.optional(v.string()), // Hosted Checkout URL (if applicable)
+    autoCapture: v.optional(v.boolean()),
+  })
+    .index("by_session_id", ["sessionId"])
+    .index("by_shopper_reference", ["shopperReference"])
+    .index("by_merchant_reference", ["merchantReference"]),
+});
+

package/src/component/setup.test.ts

@@ -0,0 +1,11 @@
+/// <reference types="vite/client" />
+import { test } from "vitest";
+import schema from "./schema.js";
+import { convexTest } from "convex-test";
+export const modules = import.meta.glob("./**/*.*s");
+
+export function initConvexTest() {
+  const t = convexTest(schema, modules);
+  return t;
+}
+test("setup", () => {});