@lenso/payments 0.0.0-stage → 0.1.1

package/dist/manage.js

@@ -0,0 +1,38 @@
+// src/manage.ts
+import { definePlugin } from "@lenso/core/plugin";
+import { defineOperation } from "@lenso/engine/operations";
+import { defineManage } from "@lenso/manage";
+import { z } from "zod";
+function createPaymentsManage(options) {
+  const plugin = definePlugin({
+    id: options.id,
+    requires: [options.payments],
+    setup(context) {
+      const payments = context.get(options.payments).payments;
+      return {
+        status(input, invocation) {
+          return payments.get(input, invocation.actor);
+        }
+      };
+    }
+  });
+  const operations = [
+    defineOperation({
+      plugin,
+      method: "status",
+      context: true,
+      input: z.object({ paymentId: z.string().min(1).max(256) }).strict(),
+      description: "Read an authorized payment and refund status, without payment secrets.",
+      effect: "read",
+      destructive: false,
+      retry: "safe",
+      cancellation: "none",
+      outputDescription: "Safe payment status; no client secret or provider credentials.",
+      source: { file: "packages/payments/src/manage.ts", export: "createPaymentsManage" }
+    })
+  ];
+  return { plugin, operations, manage: defineManage({ plugin, operations }) };
+}
+export {
+  createPaymentsManage
+};

package/dist/plugin.d.ts

@@ -0,0 +1,11 @@
+import { type Plugin } from "@lenso/core/plugin";
+import { type PaymentsRuntime } from "./index";
+import type { PaymentsAuthorization, PaymentsProvider, PaymentsStore } from "./contracts";
+import type { PaymentsConfigBinding } from "./config";
+export declare function createPaymentsPlugin<A>(options: {
+    id: string;
+    store: Plugin<PaymentsStore>;
+    provider: Plugin<PaymentsProvider>;
+    authorization: Plugin<PaymentsAuthorization<A>>;
+    config?: PaymentsConfigBinding;
+}): Plugin<PaymentsRuntime<A>>;

package/dist/plugin.js

@@ -0,0 +1,25 @@
+import {
+  createPayments2
+} from "./index-bzm562dq.js";
+
+// src/plugin.ts
+import { definePlugin } from "@lenso/core/plugin";
+function createPaymentsPlugin(options) {
+  return definePlugin({
+    id: options.id,
+    requires: [options.store, options.provider, options.authorization],
+    config: options.config,
+    setup(context) {
+      const config = options.config ? context.config(options.config) : undefined;
+      return createPayments2({
+        store: context.get(options.store),
+        provider: context.get(options.provider),
+        authorize: context.get(options.authorization),
+        ...config
+      });
+    }
+  });
+}
+export {
+  createPaymentsPlugin
+};

package/dist/scheduler.d.ts

@@ -0,0 +1,17 @@
+import type { Actor } from "@lenso/auth";
+import type { Scheduler, ScheduleRule, ScheduleSummary } from "@lenso/scheduler";
+import type { createPaymentsReconciliationTask } from "./tasks";
+/**
+ * Explicit one-time provisioning, not startup work. Persist the returned schedule ID;
+ * subsequent management uses Scheduler's authorized get/update/pause/cancel methods.
+ */
+export declare function createPaymentsRecoverySchedule<A extends Actor>(options: {
+    scheduler: Pick<Scheduler<A>, "create">;
+    /** The exact reconciliation Task registered in both Scheduler and the existing Tasks queue. */
+    task: ReturnType<typeof createPaymentsReconciliationTask>;
+    rule: Extract<ScheduleRule, {
+        kind: "cron";
+    }>;
+    limit?: number;
+    graceMs?: number;
+}, actor: A): Promise<ScheduleSummary>;

package/dist/scheduler.js

@@ -0,0 +1,24 @@
+import {
+  PaymentsError2
+} from "./index-qtpqn1xv.js";
+
+// src/scheduler.ts
+async function createPaymentsRecoverySchedule(options, actor) {
+  const limit = options.limit ?? 50;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200 || options.rule.kind !== "cron")
+    throw new PaymentsError2("invalid-input");
+  return options.scheduler.create({
+    task: options.task.name,
+    input: { limit },
+    rule: {
+      kind: "cron",
+      expression: options.rule.expression,
+      timezone: options.rule.timezone
+    },
+    misfire: "coalesce",
+    graceMs: options.graceMs ?? 5000
+  }, actor);
+}
+export {
+  createPaymentsRecoverySchedule
+};

package/dist/stripe.d.ts

@@ -0,0 +1,17 @@
+import Stripe from "stripe";
+import { type PaymentsProvider } from "./contracts";
+export interface StripeProviderOptions {
+    /** Borrowed, single-account SDK client. Its owner retains its lifetime. */
+    client: Stripe;
+    accountId: string;
+    live: boolean;
+    webhookSecret: string;
+    currencies: Record<string, {
+        min: number;
+        max: number;
+        multiple?: number;
+    }>;
+    toleranceSeconds?: number;
+    requestTimeoutMs?: number;
+}
+export declare function createStripeProvider(options: StripeProviderOptions): PaymentsProvider;

package/dist/stripe.js

@@ -0,0 +1,308 @@
+import {
+  PaymentsError2,
+  RefundNotCreatedError2
+} from "./index-qtpqn1xv.js";
+
+// src/stripe.ts
+import Stripe from "stripe";
+var paymentStatuses = new Set([
+  "requires_payment_method",
+  "requires_confirmation",
+  "requires_action",
+  "processing",
+  "requires_capture",
+  "succeeded",
+  "canceled"
+]);
+var refundStatuses = new Set(["pending", "requires_action", "succeeded", "failed", "canceled"]);
+var positiveInteger = (value) => Number.isSafeInteger(value) && value > 0;
+var identity = (value) => typeof value === "string" && value.length > 0 && value.length <= 256;
+var mismatch = () => new PaymentsError2("provider-mismatch");
+function createStripeProvider(options) {
+  const { client, accountId, live, webhookSecret } = options;
+  const tolerance = options.toleranceSeconds ?? 300;
+  const timeout = options.requestTimeoutMs ?? 1e4;
+  if (!identity(accountId) || typeof live !== "boolean" || !webhookSecret || !positiveInteger(tolerance) || !positiveInteger(timeout) || timeout > 60000) {
+    throw new PaymentsError2("invalid-input");
+  }
+  const currencies = new Map(Object.entries(options.currencies).map(([currency, rule]) => {
+    if (!/^[a-z]{3}$/.test(currency) || !positiveInteger(rule.min) || !positiveInteger(rule.max) || rule.min > rule.max || rule.multiple !== undefined && !positiveInteger(rule.multiple)) {
+      throw new PaymentsError2("invalid-input");
+    }
+    return [currency, { ...rule }];
+  }));
+  const requestOptions = { maxNetworkRetries: 0, timeout };
+  function validate(amount, currency, charge) {
+    const rule = currencies.get(currency);
+    if (!rule || !positiveInteger(amount) || amount > rule.max || charge && amount < rule.min || amount % (rule.multiple ?? 1) !== 0 || (currency === "isk" || currency === "ugx") && amount % 100 !== 0) {
+      throw new PaymentsError2("invalid-input");
+    }
+  }
+  async function request(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error instanceof PaymentsError2)
+        throw error;
+      throw new PaymentsError2("unavailable");
+    }
+  }
+  function checkClient() {
+    if (client.getApiField("stripeAccount") || client.getApiField("stripeContext")) {
+      throw mismatch();
+    }
+  }
+  let accountCheck;
+  async function checkAccount() {
+    checkClient();
+    accountCheck ??= request(async () => {
+      const account = await client.accounts.retrieve(null, {}, requestOptions);
+      if (account.id !== accountId)
+        throw mismatch();
+    }).catch((error) => {
+      accountCheck = undefined;
+      throw error;
+    });
+    await accountCheck;
+  }
+  function projectPayment(pi) {
+    const metadata = pi.metadata;
+    if (pi.object !== "payment_intent" || !identity(pi.id) || pi.livemode !== live || !metadata || !identity(metadata.lenso_payment_id) || !identity(metadata.lenso_tenant_id) || !identity(metadata.lenso_order_id) || !paymentStatuses.has(pi.status) || !Number.isSafeInteger(pi.amount_received) || pi.amount_received < 0 || pi.amount_received > pi.amount)
+      throw mismatch();
+    try {
+      validate(pi.amount, pi.currency, true);
+    } catch {
+      throw mismatch();
+    }
+    return {
+      id: pi.id,
+      paymentId: metadata.lenso_payment_id,
+      tenantId: metadata.lenso_tenant_id,
+      orderId: metadata.lenso_order_id,
+      accountId,
+      live,
+      amount: pi.amount,
+      received: pi.amount_received,
+      currency: pi.currency,
+      status: pi.status
+    };
+  }
+  function matchPayment(payment, record) {
+    if (record.accountId !== accountId || record.live !== live || payment.paymentId !== record.paymentId || payment.tenantId !== record.tenantId || payment.orderId !== record.orderId || payment.amount !== record.amount || payment.currency !== record.currency || record.providerId !== null && payment.id !== record.providerId)
+      throw mismatch();
+  }
+  async function retrievePayment(id) {
+    if (!identity(id))
+      throw new PaymentsError2("invalid-input");
+    await checkAccount();
+    const pi = await request(() => client.paymentIntents.retrieve(id, {}, requestOptions));
+    if (pi.id !== id)
+      throw mismatch();
+    projectPayment(pi);
+    return pi;
+  }
+  async function projectRefund(refund) {
+    const piId = typeof refund.payment_intent === "string" ? refund.payment_intent : refund.payment_intent?.id;
+    if (refund.object !== "refund" || !identity(refund.id) || !identity(piId) || !refund.metadata || !identity(refund.metadata.lenso_refund_id) || !identity(refund.metadata.lenso_payment_id) || !refundStatuses.has(refund.status ?? "")) {
+      throw mismatch();
+    }
+    const payment = projectPayment(await retrievePayment(piId));
+    if (refund.metadata.lenso_payment_id !== payment.paymentId || refund.currency !== payment.currency || refund.amount > payment.amount)
+      throw mismatch();
+    try {
+      validate(refund.amount, refund.currency, false);
+    } catch {
+      throw mismatch();
+    }
+    return {
+      id: refund.id,
+      refundId: refund.metadata.lenso_refund_id,
+      paymentId: payment.paymentId,
+      paymentProviderId: payment.id,
+      accountId,
+      live: payment.live,
+      amount: refund.amount,
+      currency: refund.currency,
+      status: refund.status
+    };
+  }
+  function matchRefund(value, record, refund) {
+    if (value.refundId !== refund.refundId || value.paymentId !== record.paymentId || value.paymentProviderId !== record.providerId || value.amount !== refund.amount || value.currency !== record.currency || refund.providerId !== null && value.id !== refund.providerId)
+      throw mismatch();
+  }
+  function writeOptions(key) {
+    if (typeof key !== "string" || !key.length || key.length > 255) {
+      throw new PaymentsError2("invalid-input");
+    }
+    return { ...requestOptions, idempotencyKey: key };
+  }
+  async function scan(page, matches) {
+    let cursor;
+    let found = null;
+    for (let count = 0;count < 100; count++) {
+      const result = await request(() => page(cursor));
+      for (const value of result.data) {
+        if (matches(value)) {
+          if (found)
+            throw mismatch();
+          found = value;
+        }
+      }
+      if (!result.has_more)
+        return found;
+      const next = result.data.at(-1)?.id;
+      if (!next || next === cursor)
+        throw new PaymentsError2("unavailable");
+      cursor = next;
+    }
+    throw new PaymentsError2("unavailable");
+  }
+  return {
+    accountId,
+    live,
+    replayWindowMs: 23 * 60 * 60 * 1000,
+    validateAmount: (amount, currency) => validate(amount, currency, true),
+    validateRefundAmount: (amount, currency) => validate(amount, currency, false),
+    async createPayment(record, key, beforeWrite) {
+      validate(record.amount, record.currency, true);
+      if (record.accountId !== accountId || record.live !== live || !identity(record.paymentId) || !identity(record.tenantId) || !identity(record.orderId)) {
+        throw new PaymentsError2("invalid-input");
+      }
+      const opts = writeOptions(key);
+      await checkAccount();
+      await beforeWrite?.();
+      const payment = projectPayment(await request(() => client.paymentIntents.create({
+        amount: record.amount,
+        currency: record.currency,
+        capture_method: "automatic",
+        automatic_payment_methods: { enabled: true },
+        metadata: {
+          lenso_payment_id: record.paymentId,
+          lenso_tenant_id: record.tenantId,
+          lenso_order_id: record.orderId
+        }
+      }, opts)));
+      matchPayment(payment, record);
+      return payment;
+    },
+    async getPayment(id) {
+      return projectPayment(await retrievePayment(id));
+    },
+    async findPayment(record) {
+      if (record.accountId !== accountId || record.live !== live)
+        throw mismatch();
+      const since = record.attemptedAt ?? record.createdAt;
+      if (!Number.isSafeInteger(since) || since < 0)
+        throw new PaymentsError2("invalid-input");
+      await checkAccount();
+      const pi = await scan((cursor) => client.paymentIntents.list({
+        limit: 100,
+        created: { gte: Math.max(0, Math.floor(since / 1000) - tolerance) },
+        ...cursor ? { starting_after: cursor } : {}
+      }, requestOptions), (value) => value.metadata?.lenso_payment_id === record.paymentId);
+      if (!pi)
+        return null;
+      const payment = projectPayment(pi);
+      matchPayment(payment, record);
+      return payment;
+    },
+    async clientSecret(id) {
+      const pi = await retrievePayment(id);
+      if (pi.client_secret !== null && typeof pi.client_secret !== "string")
+        throw mismatch();
+      return pi.client_secret;
+    },
+    async createRefund(record, refund, key, beforeWrite) {
+      validate(refund.amount, record.currency, false);
+      if (!identity(refund.refundId) || !identity(record.providerId) || refund.amount > record.amount) {
+        throw new PaymentsError2("invalid-input");
+      }
+      const opts = writeOptions(key);
+      const payment = projectPayment(await retrievePayment(record.providerId));
+      matchPayment(payment, record);
+      await beforeWrite?.();
+      let created;
+      try {
+        created = await client.refunds.create({
+          payment_intent: record.providerId,
+          amount: refund.amount,
+          metadata: { lenso_refund_id: refund.refundId, lenso_payment_id: record.paymentId }
+        }, opts);
+      } catch (error) {
+        if (error instanceof Stripe.errors.StripeInvalidRequestError && error.statusCode === 400 && ["charge_already_refunded", "charge_disputed", "refund_disputed_payment"].includes(error.code ?? "")) {
+          throw new RefundNotCreatedError2;
+        }
+        throw new PaymentsError2("unavailable");
+      }
+      const value = await projectRefund(created);
+      matchRefund(value, record, refund);
+      return value;
+    },
+    async getRefund(id) {
+      if (!identity(id))
+        throw new PaymentsError2("invalid-input");
+      await checkAccount();
+      const refund = await request(() => client.refunds.retrieve(id, {}, requestOptions));
+      if (refund.id !== id)
+        throw mismatch();
+      return projectRefund(refund);
+    },
+    async findRefund(record, refund) {
+      if (!identity(record.providerId))
+        throw new PaymentsError2("invalid-input");
+      const payment = projectPayment(await retrievePayment(record.providerId));
+      matchPayment(payment, record);
+      const value = await scan((cursor) => client.refunds.list({
+        payment_intent: record.providerId,
+        limit: 100,
+        ...cursor ? { starting_after: cursor } : {}
+      }, requestOptions), (item) => item.metadata?.lenso_refund_id === refund.refundId);
+      if (!value)
+        return null;
+      const result = await projectRefund(value);
+      matchRefund(result, record, refund);
+      return result;
+    },
+    async verifyWebhook(raw, signature) {
+      let event;
+      try {
+        event = await client.webhooks.constructEventAsync(raw, signature, webhookSecret, tolerance, Stripe.createSubtleCryptoProvider());
+        let timestamp = NaN;
+        for (const part of signature.split(",")) {
+          const [name, value] = part.split("=");
+          if (name === "t")
+            timestamp = Number(value);
+        }
+        if (!Number.isSafeInteger(timestamp) || timestamp > Math.floor(Date.now() / 1000) + tolerance) {
+          throw new Error;
+        }
+      } catch {
+        throw new PaymentsError2("bad-signature");
+      }
+      if (!identity(event.id) || event.livemode !== live || event.account !== undefined || event.context !== undefined) {
+        throw mismatch();
+      }
+      if (event.type.startsWith("payment_intent.")) {
+        await checkAccount();
+        return {
+          eventId: event.id,
+          accountId,
+          live,
+          object: projectPayment(event.data.object)
+        };
+      }
+      if (event.type === "refund.created" || event.type === "refund.updated" || event.type === "refund.failed") {
+        return {
+          eventId: event.id,
+          accountId,
+          live,
+          object: await projectRefund(event.data.object)
+        };
+      }
+      return null;
+    }
+  };
+}
+export {
+  createStripeProvider
+};

package/dist/tasks.d.ts

@@ -0,0 +1,18 @@
+import { type Task, type TaskQueue } from "@lenso/tasks";
+import { z } from "zod";
+import type { PaymentsRuntime } from "./index";
+/** Register this exact Task object in the existing queue; credentials never enter the payload. */
+export declare function createPaymentsReconciliationTask(options: {
+    name: string;
+    runtime: () => PaymentsRuntime<unknown>["reconciliation"];
+    queue: () => Pick<TaskQueue, "enqueue">;
+    /** Disable when Scheduler owns periodic recovery; avoids accumulating parallel polling chains. */
+    continuation?: boolean;
+}): Task<z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, {
+    payments: number;
+    events: number;
+    unresolved: number;
+    nextRunAt: number | null;
+}>;

package/dist/tasks.js

@@ -0,0 +1,40 @@
+import {
+  PaymentsError2
+} from "./index-qtpqn1xv.js";
+
+// src/tasks.ts
+import { defineTask } from "@lenso/tasks";
+import { z } from "zod";
+function createPaymentsReconciliationTask(options) {
+  if (options.continuation !== undefined && typeof options.continuation !== "boolean")
+    throw new PaymentsError2("invalid-input");
+  const input = z.object({ limit: z.number().int().min(1).max(200).default(50) }).strict();
+  const task = defineTask({
+    name: options.name,
+    input,
+    maxAttempts: 5,
+    retry: { delaySeconds: 30, backoff: true, maxDelaySeconds: 300 },
+    async handler({ limit }, context) {
+      context.signal.throwIfAborted();
+      const result = await options.runtime().drain(limit);
+      context.signal.throwIfAborted();
+      if (options.continuation !== false && result.nextRunAt !== null) {
+        await options.queue().enqueue(task, { limit }, {
+          runAt: new Date(Math.max(result.nextRunAt, Date.now() + 1000)),
+          deduplicationKey: `payments.continue:${context.jobId}:${result.nextRunAt}`
+        });
+      }
+      return result;
+    },
+    result: (value) => ({
+      payments: value.payments,
+      events: value.events,
+      unresolved: value.unresolved,
+      nextRunAt: value.nextRunAt
+    })
+  });
+  return task;
+}
+export {
+  createPaymentsReconciliationTask
+};

package/migrations/postgres.sql

@@ -0,0 +1,23 @@
+CREATE TABLE lenso_payments (
+  payment_id text PRIMARY KEY,
+  order_key text NOT NULL UNIQUE,
+  account_id text NOT NULL,
+  live integer NOT NULL CHECK (live IN (0, 1)),
+  revision integer NOT NULL CHECK (revision >= 0),
+  reconcile_at bigint NOT NULL,
+  data jsonb NOT NULL
+);
+CREATE INDEX lenso_payments_due_idx ON lenso_payments (account_id, live, reconcile_at, payment_id);
+CREATE TABLE lenso_payment_events (
+  event_key text PRIMARY KEY,
+  event_id text NOT NULL,
+  payment_id text NOT NULL,
+  object_id text NOT NULL,
+  refund_id text,
+  account_id text NOT NULL,
+  live integer NOT NULL CHECK (live IN (0, 1)),
+  created_at bigint NOT NULL,
+  reconcile_at bigint NOT NULL,
+  done integer NOT NULL CHECK (done IN (0, 1))
+);
+CREATE INDEX lenso_payment_events_due_idx ON lenso_payment_events (account_id, live, done, reconcile_at, event_key);

package/migrations/sqlite.sql

@@ -0,0 +1,23 @@
+CREATE TABLE lenso_payments (
+  payment_id TEXT PRIMARY KEY,
+  order_key TEXT NOT NULL UNIQUE,
+  account_id TEXT NOT NULL,
+  live INTEGER NOT NULL CHECK (live IN (0, 1)),
+  revision INTEGER NOT NULL CHECK (revision >= 0),
+  reconcile_at INTEGER NOT NULL,
+  data TEXT NOT NULL CHECK (json_valid(data))
+);
+CREATE INDEX lenso_payments_due_idx ON lenso_payments (account_id, live, reconcile_at, payment_id);
+CREATE TABLE lenso_payment_events (
+  event_key TEXT PRIMARY KEY,
+  event_id TEXT NOT NULL,
+  payment_id TEXT NOT NULL,
+  object_id TEXT NOT NULL,
+  refund_id TEXT,
+  account_id TEXT NOT NULL,
+  live INTEGER NOT NULL CHECK (live IN (0, 1)),
+  created_at INTEGER NOT NULL,
+  reconcile_at INTEGER NOT NULL,
+  done INTEGER NOT NULL CHECK (done IN (0, 1))
+);
+CREATE INDEX lenso_payment_events_due_idx ON lenso_payment_events (account_id, live, done, reconcile_at, event_key);