alepha 0.20.6 → 0.20.7

package/package.json

@@ -2,7 +2,7 @@
   "name": "alepha",
   "description": "Easy-to-use modern TypeScript framework for building many kind of applications.",
   "author": "Feunard",
-  "version": "0.20.6",
+  "version": "0.20.7",
   "type": "module",
   "engines": {
     "node": ">=22.0.0"
@@ -29,15 +29,14 @@
     "tsx": "^4.21.0",
     "typebox": "^1.1.38",
     "typescript": "^6.0.3",
-    "vite-bundle-analyzer": "^1.3.8",
-    "ws": "^8.20.0"
+    "vite-bundle-analyzer": "^1.3.8"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.14",
-    "@cloudflare/workers-types": "^4.20260508.1",
+    "@biomejs/biome": "^2.4.15",
+    "@cloudflare/workers-types": "^4.20260510.1",
     "@electric-sql/pglite": "^0.4.5",
     "@faker-js/faker": "^10.4.0",
-    "@tailwindcss/vite": "^4.2.4",
+    "@tailwindcss/vite": "^4.3.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
     "@types/bun": "^1.3.13",
@@ -45,7 +44,6 @@
     "@types/nodemailer": "^8.0.0",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "@types/ws": "^8.18.1",
     "cron-schedule": "^6.0.0",
     "drizzle-kit": "^0.31.10",
     "jose": "^6.2.3",
@@ -57,7 +55,7 @@
     "react-dom": "^19.2.6",
     "shadcn": "^4.7.0",
     "swagger-ui-dist": "^5.32.5",
-    "tailwindcss": "^4.2.4",
+    "tailwindcss": "^4.3.0",
     "tsdown": "^0.22.0",
     "vite": "^8.0.11",
     "vitest": "^4.1.5"
@@ -151,6 +149,11 @@
       "import": "./dist/api/payments/index.js",
       "default": "./dist/api/payments/index.js"
     },
+    "./api/subscriptions": {
+      "types": "./dist/api/subscriptions/index.d.ts",
+      "import": "./dist/api/subscriptions/index.js",
+      "default": "./dist/api/subscriptions/index.js"
+    },
     "./api/users": {
       "types": "./dist/api/users/index.d.ts",
       "react-native": "./dist/api/users/index.browser.js",
@@ -369,11 +372,6 @@
       "import": "./dist/react/ui/index.js",
       "default": "./dist/react/ui/index.js"
     },
-    "./react/websocket": {
-      "types": "./dist/react/websocket/index.d.ts",
-      "import": "./dist/react/websocket/index.js",
-      "default": "./dist/react/websocket/index.js"
-    },
     "./redis": {
       "types": "./dist/redis/index.d.ts",
       "bun": "./dist/redis/index.bun.js",
@@ -494,13 +492,6 @@
       "import": "./dist/topic/redis/index.js",
       "default": "./dist/topic/redis/index.js"
     },
-    "./websocket": {
-      "types": "./dist/websocket/index.d.ts",
-      "react-native": "./dist/websocket/index.browser.js",
-      "browser": "./dist/websocket/index.browser.js",
-      "import": "./dist/websocket/index.js",
-      "default": "./dist/websocket/index.js"
-    },
     "./tsconfig.base": "./tsconfig.base.json",
     "./package.json": "./package.json"
   },
@@ -561,6 +552,11 @@
         "import": "./dist/api/payments/index.js",
         "default": "./dist/api/payments/index.js"
       },
+      "./api/subscriptions": {
+        "types": "./dist/api/subscriptions/index.d.ts",
+        "import": "./dist/api/subscriptions/index.js",
+        "default": "./dist/api/subscriptions/index.js"
+      },
       "./api/users": {
         "types": "./dist/api/users/index.d.ts",
         "react-native": "./dist/api/users/index.browser.js",
@@ -779,11 +775,6 @@
         "import": "./dist/react/ui/index.js",
         "default": "./dist/react/ui/index.js"
       },
-      "./react/websocket": {
-        "types": "./dist/react/websocket/index.d.ts",
-        "import": "./dist/react/websocket/index.js",
-        "default": "./dist/react/websocket/index.js"
-      },
       "./redis": {
         "types": "./dist/redis/index.d.ts",
         "bun": "./dist/redis/index.bun.js",
@@ -904,13 +895,6 @@
         "import": "./dist/topic/redis/index.js",
         "default": "./dist/topic/redis/index.js"
       },
-      "./websocket": {
-        "types": "./dist/websocket/index.d.ts",
-        "react-native": "./dist/websocket/index.browser.js",
-        "browser": "./dist/websocket/index.browser.js",
-        "import": "./dist/websocket/index.js",
-        "default": "./dist/websocket/index.js"
-      },
       "./tsconfig.base": "./tsconfig.base.json",
       "./package.json": "./package.json"
     }

package/src/api/audits/entities/audits.ts

@@ -26,6 +26,7 @@ export const audits = $entity({
   schema: t.object({
     id: db.primaryKey(t.bigint()),
     createdAt: db.createdAt(),
+    organizationId: db.organization(),
 
     /**
      * Audit event type (e.g., "auth", "user", "payment", "system").

package/src/api/files/entities/files.ts

@@ -8,6 +8,7 @@ export const files = $entity({
     version: db.version(),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
+    organizationId: db.organization(),
     blobId: t.text(),
     creator: t.optional(t.uuid()),
     creatorRealm: t.optional(t.string()),

package/src/api/jobs/__tests__/$job.spec.ts

@@ -21,6 +21,29 @@ const makeApp = () =>
 const makeAppDirect = () =>
   Alepha.create().with(AlephaOrmPostgres).with(AlephaApiJobs);
 
+/**
+ * Poll `fn` until `predicate` returns true, or throw on timeout.
+ * Use this instead of `setTimeout(r, fixedMs)` — fixed sleeps race the
+ * in-memory queue under CI load and produce flaky failures.
+ */
+async function waitFor<T>(
+  fn: () => Promise<T> | T,
+  predicate: (v: T) => boolean,
+  { timeout = 2000, interval = 10, label = "condition" } = {},
+): Promise<T> {
+  const deadline = Date.now() + timeout;
+  let last: T = await fn();
+  while (Date.now() < deadline) {
+    if (predicate(last)) return last;
+    await new Promise((r) => setTimeout(r, interval));
+    last = await fn();
+  }
+  if (predicate(last)) return last;
+  throw new Error(
+    `waitFor: ${label} not met within ${timeout}ms; last value: ${JSON.stringify(last)}`,
+  );
+}
+
 describe("$job — registration validation", () => {
   it("rejects jobs declaring both cron and schema", async ({ expect }) => {
     const alepha = makeApp();
@@ -136,13 +159,12 @@ describe("$job — queue mode (outbox)", () => {
     await alepha.start();
     await app.work.push({ n: 42 });
 
-    // Memory queue is synchronous-ish; processing completes promptly.
-    await new Promise((r) => setTimeout(r, 50));
-
+    const rows = await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r.length === 0 && received !== undefined,
+      { label: "row deleted on success" },
+    );
     expect(received).toEqual({ n: 42 });
-    const rows = await app.executions.findMany({
-      where: { jobName: { eq: "App.work" } },
-    });
     expect(rows).toHaveLength(0);
   });
 
@@ -159,10 +181,11 @@ describe("$job — queue mode (outbox)", () => {
     const app = alepha.inject(App);
     await alepha.start();
     await app.work.push({ n: 1 });
-    await new Promise((r) => setTimeout(r, 50));
-    const rows = await app.executions.findMany({
-      where: { jobName: { eq: "App.work" } },
-    });
+    const rows = await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r.length === 1 && r[0].status === "ok",
+      { label: "row reaches status=ok" },
+    );
     expect(rows).toHaveLength(1);
     expect(rows[0].status).toBe("ok");
   });
@@ -209,11 +232,12 @@ describe("$job — queue mode (outbox)", () => {
     const app = alepha.inject(App);
     await alepha.start();
     await app.work.push({ v: 1 }, { delay: [1, "hour"] });
-    await new Promise((r) => setTimeout(r, 50));
+    const rows = await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r.length === 1 && r[0].status === "scheduled",
+      { label: "row reaches status=scheduled" },
+    );
     expect(calls).toBe(0);
-    const rows = await app.executions.findMany({
-      where: { jobName: { eq: "App.work" } },
-    });
     expect(rows).toHaveLength(1);
     expect(rows[0].status).toBe("scheduled");
     expect(rows[0].scheduledAt).toBeTruthy();
@@ -265,10 +289,12 @@ describe("$job — queue mode (outbox)", () => {
     const app = alepha.inject(App);
     await alepha.start();
     await app.work.push({ v: 1 });
-    await new Promise((r) => setTimeout(r, 50));
-    const rows = await app.executions.findMany({
-      where: { jobName: { eq: "App.work" } },
-    });
+    const rows = await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) =>
+        r.length === 1 && r[0].status === "scheduled" && r[0].attempt === 1,
+      { label: "row rescheduled after first failure" },
+    );
     expect(rows).toHaveLength(1);
     expect(rows[0].status).toBe("scheduled");
     expect(rows[0].attempt).toBe(1);
@@ -297,10 +323,11 @@ describe("$job — queue mode (outbox)", () => {
     const app = alepha.inject(App);
     await alepha.start();
     await app.work.push({ v: 1 });
-    await new Promise((r) => setTimeout(r, 100));
-    const rows = await app.executions.findMany({
-      where: { jobName: { eq: "App.work" } },
-    });
+    const rows = await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r.length === 1 && r[0].status === "error",
+      { label: "row reaches terminal status=error" },
+    );
     expect(rows).toHaveLength(1);
     expect(rows[0].status).toBe("error");
     expect(rows[0].error).toBe("dead");
@@ -579,18 +606,31 @@ describe("$job — retry semantics", () => {
 
     await app.work.push({ v: 1 });
 
-    // First attempt runs immediately. Subsequent retries are sweep-driven.
-    await new Promise((r) => setTimeout(r, 100));
+    // First attempt runs immediately, then the row is rescheduled with attempt=1.
+    // Wait for that stable state before sweeping (sweep needs status=scheduled).
+    await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r[0]?.status === "scheduled" && r[0]?.attempt === 1,
+      { label: "row rescheduled after attempt 1" },
+    );
     expect(attempts).toBe(1);
 
     const provider = alepha.inject(JobProvider);
     // Trigger sweeps manually — each one should claim and run the next attempt.
     await (provider as any).sweep();
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r[0]?.status === "scheduled" && r[0]?.attempt === 2,
+      { label: "row rescheduled after attempt 2" },
+    );
     expect(attempts).toBe(2);
 
     await (provider as any).sweep();
-    await new Promise((r) => setTimeout(r, 50));
+    await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.work" } } }),
+      (r) => r[0]?.status === "error" && r[0]?.attempt === 3,
+      { label: "row terminal after attempt 3" },
+    );
     expect(attempts).toBe(3);
 
     // After 3 attempts the row is terminal — no more retries.
@@ -640,11 +680,16 @@ describe("$job — cancel race", () => {
 
     await app.slow.cancel(id);
 
-    // Give the handler's abort path a moment to execute and (without the
-    // guard) try to overwrite the row.
-    await new Promise((r) => setTimeout(r, 100));
-
-    const final = await app.executions.findById(id);
+    // Confirm the row is `cancelled` and stays that way — without the guard,
+    // the handler's abort path would race to overwrite to `error`. Poll for a
+    // stable window so the (buggy) overwrite would be caught.
+    const settleDeadline = Date.now() + 300;
+    let final: any;
+    while (Date.now() < settleDeadline) {
+      final = await app.executions.findById(id);
+      if (final?.status !== "cancelled") break;
+      await new Promise((r) => setTimeout(r, 20));
+    }
     expect(final?.status).toBe("cancelled");
     expect(final?.error).toBeFalsy();
   });
@@ -695,11 +740,16 @@ describe("$job — cron + retry (outbox path)", () => {
 
     // Sweep picks it up and runs attempt 2 → terminal.
     await (provider as any).sweep();
-    await new Promise((r) => setTimeout(r, 100));
-    expect(attempts).toBe(2);
-    const rows2 = await app.executions.findMany({
-      where: { jobName: { eq: "App.tick" } },
-    });
+    await waitFor(
+      () => attempts,
+      (n) => n === 2,
+      { label: "second attempt runs after cron sweep" },
+    );
+    const rows2 = await waitFor(
+      () => app.executions.findMany({ where: { jobName: { eq: "App.tick" } } }),
+      (r) => r[0]?.status === "error",
+      { label: "row reaches terminal error" },
+    );
     expect(rows2[0].status).toBe("error");
   });
 });
@@ -765,12 +815,14 @@ describe("$job — admin resource shape", () => {
     await alepha.start();
 
     const id = await app.work.push({ v: 1 });
-    // Wait for the handler to finish so the row is `ok` (record: all keeps it).
-    await new Promise((r) => setTimeout(r, 100));
-
     const { JobService } = await import("../services/JobService.ts");
     const svc = alepha.inject(JobService);
-    const resource = await svc.getExecution(id);
+    // Wait for the handler to finish so the row is `ok` (record: all keeps it).
+    const resource = await waitFor(
+      () => svc.getExecution(id),
+      (r) => r?.status === "ok",
+      { label: "execution reaches status=ok" },
+    );
     expect(resource.priority).toBe("high");
     expect(typeof resource.priority).toBe("string");
   });

package/src/api/jobs/entities/jobExecutionEntity.ts

@@ -54,6 +54,7 @@ export const jobExecutionEntity = $entity({
   }),
   indexes: [
     { columns: ["jobName", "status", "scheduledAt"] },
+    { columns: ["jobName", "status", "createdAt"] },
     { columns: ["jobName", "startedAt"] },
     { columns: ["jobName", "key"], unique: true },
   ],

package/src/api/jobs/providers/JobProvider.ts

@@ -112,7 +112,11 @@ export type JobEffectiveMode = "cron" | "queue" | "direct";
  *   - re-enqueue pending rows older than `staleThreshold`
  *   - mark crashed running rows as failed and apply retry policy
  *   - move `scheduled` rows with `scheduledAt <= now` to pending + dispatch
- *   - trim per-job history beyond `keepLastSuccess` / `keepLastError`
+ *
+ * Trim runs on its own cron (`trimCron`, default hourly):
+ *   - per-job history trimmed beyond `keepLastSuccess` / `keepLastError`
+ *   - decoupled from sweep because trim cost scales with job count, not
+ *     retry latency — running it every sweep is wasted work for most apps.
  */
 export class JobProvider {
   protected readonly alepha = $inject(Alepha);
@@ -1127,9 +1131,6 @@ export class JobProvider {
           await this.handleFailure(exec.id, reg, exec.attempt, err, "");
         }
       }
-
-      // 4. Trim ring buffer per job
-      await this.trimRingBuffers();
     } catch (e) {
       this.log.error("Sweep failed", { error: e });
     }
@@ -1188,7 +1189,7 @@ export class JobProvider {
     try {
       const rows = await this.executions.findMany({
         where: { jobName: { eq: jobName }, status: { eq: status } },
-        orderBy: { column: "startedAt", direction: "desc" },
+        orderBy: { column: "createdAt", direction: "desc" },
         limit: keep + 50,
       });
       if (rows.length <= keep) return;
@@ -1251,6 +1252,20 @@ export class JobProvider {
         },
         true,
       );
+
+      this.cronProvider.createCronJob(
+        "api:jobs:trim",
+        this.config.trimCron,
+        async () => {
+          if (this.stopping) return;
+          try {
+            await this.trimRingBuffers();
+          } catch (e) {
+            this.log.error("Trim failed", { error: e });
+          }
+        },
+        true,
+      );
     },
   });
 

package/src/api/jobs/schemas/jobConfigAtom.ts

@@ -8,6 +8,10 @@ export const jobConfig = $atom({
       description:
         "Cron expression for the sweep tick. Must be minute-granular at minimum (cron resolution). On Cloudflare Workers this expression is emitted into wrangler.jsonc by the build.",
     }),
+    trimCron: t.text({
+      description:
+        "Cron expression for the ring-buffer trim tick (per-job keepLastSuccess/keepLastError enforcement). Decoupled from `sweepCron` because trim is bounded by job execution rate, not retry latency — running it every sweep is wasted work for most apps.",
+    }),
     staleThreshold: t.integer({
       description: "Pending age (ms) before the sweep re-dispatches it.",
     }),
@@ -31,6 +35,7 @@ export const jobConfig = $atom({
   }),
   default: {
     sweepCron: "*/5 * * * *",
+    trimCron: "0 * * * *",
     staleThreshold: 300_000,
     runTimeout: 1_800_000,
     keepLastSuccess: 10,

package/src/api/keys/entities/apiKeyEntity.ts

@@ -7,6 +7,7 @@ export const apiKeyEntity = $entity({
     id: db.primaryKey(t.uuid()),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
+    organizationId: db.organization(),
 
     // Owner
     userId: t.uuid(),

package/src/api/payments/controllers/MockCheckoutController.ts

@@ -0,0 +1,146 @@
+import { $inject, t } from "alepha";
+import { $route, type ServerReply } from "alepha/server";
+import { MemoryPaymentProvider } from "../providers/MemoryPaymentProvider.ts";
+import { PaymentProvider } from "../providers/PaymentProvider.ts";
+import { PaymentService } from "../services/PaymentService.ts";
+
+const FORBIDDEN_HTML =
+  "<!doctype html><meta charset=utf-8><title>Mock checkout</title>" +
+  "<p>Mock checkout is only available with the in-memory payment provider.</p>";
+
+const escapeHtml = (s: string) =>
+  s.replace(/[&<>"']/g, (c) =>
+    c === "&"
+      ? "&amp;"
+      : c === "<"
+        ? "&lt;"
+        : c === ">"
+          ? "&gt;"
+          : c === '"'
+            ? "&quot;"
+            : "&#39;",
+  );
+
+const formatAmount = (cents: number, currency: string) => {
+  const value = (cents / 100).toFixed(2);
+  return `${value} ${currency.toUpperCase()}`;
+};
+
+const renderPage = (opts: {
+  intentId: string;
+  amount: string;
+  returnUrl: string;
+}) => `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Mock checkout</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    :root { color-scheme: light dark; font-family: system-ui, sans-serif; }
+    body { display:flex; min-height:100vh; align-items:center; justify-content:center; margin:0; background:#f6f7f9; }
+    .card { background:#fff; padding:2rem; border-radius:12px; box-shadow:0 8px 24px rgba(0,0,0,.08); max-width:380px; width:100%; }
+    h1 { margin:0 0 .25rem; font-size:1.1rem; }
+    .badge { display:inline-block; background:#fef3c7; color:#92400e; font-size:.7rem; padding:2px 8px; border-radius:999px; margin-bottom:.75rem; }
+    .amount { font-size:2rem; font-weight:600; margin:.75rem 0 1.25rem; }
+    .row { display:flex; gap:.5rem; }
+    button { flex:1; padding:.75rem 1rem; border-radius:8px; border:0; font-size:.95rem; cursor:pointer; }
+    .pay { background:#16a34a; color:#fff; }
+    .cancel { background:#e5e7eb; color:#111; }
+    .meta { font-size:.75rem; color:#6b7280; margin-top:1rem; word-break:break-all; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <span class="badge">DEV — mock checkout</span>
+    <h1>Confirm payment</h1>
+    <div class="amount">${escapeHtml(opts.amount)}</div>
+    <div class="row">
+      <form method="post" action="/payments/mock-checkout/${opts.intentId}/cancel">
+        <input type="hidden" name="returnUrl" value="${escapeHtml(opts.returnUrl)}" />
+        <button type="submit" class="cancel">Cancel</button>
+      </form>
+      <form method="post" action="/payments/mock-checkout/${opts.intentId}/confirm">
+        <input type="hidden" name="returnUrl" value="${escapeHtml(opts.returnUrl)}" />
+        <button type="submit" class="pay">Pay</button>
+      </form>
+    </div>
+    <div class="meta">intent: ${opts.intentId}</div>
+  </div>
+</body>
+</html>`;
+
+const appendStatusParam = (returnUrl: string, status: "success" | "cancel") => {
+  try {
+    const url = new URL(returnUrl, "http://placeholder.local");
+    url.searchParams.set("booking", status);
+    return returnUrl.startsWith("http")
+      ? url.toString()
+      : url.pathname + url.search + url.hash;
+  } catch {
+    return returnUrl;
+  }
+};
+
+export class MockCheckoutController {
+  protected readonly url = "/payments/mock-checkout";
+  protected readonly payments = $inject(PaymentService);
+  protected readonly provider = $inject(PaymentProvider);
+
+  protected isMemoryProvider() {
+    return this.provider instanceof MemoryPaymentProvider;
+  }
+
+  protected forbidden(reply: ServerReply) {
+    reply.headers["content-type"] = "text/html; charset=utf-8";
+    reply.status = 403;
+    return FORBIDDEN_HTML;
+  }
+
+  public readonly mockCheckoutPage = $route({
+    method: "GET",
+    path: `${this.url}/:id`,
+    schema: {
+      params: t.object({ id: t.uuid() }),
+      query: t.object({ returnUrl: t.optional(t.text({ size: "rich" })) }),
+    },
+    handler: async ({ params, query, reply }) => {
+      if (!this.isMemoryProvider()) return this.forbidden(reply);
+      const intent = await this.payments.getIntent(params.id);
+      reply.headers["content-type"] = "text/html; charset=utf-8";
+      return renderPage({
+        intentId: intent.id,
+        amount: formatAmount(intent.amount, intent.currency),
+        returnUrl: query.returnUrl ?? "/",
+      });
+    },
+  });
+
+  public readonly mockCheckoutConfirm = $route({
+    method: "POST",
+    path: `${this.url}/:id/confirm`,
+    schema: {
+      params: t.object({ id: t.uuid() }),
+      body: t.object({ returnUrl: t.optional(t.text({ size: "rich" })) }),
+    },
+    handler: async ({ params, body, reply }) => {
+      if (!this.isMemoryProvider()) return this.forbidden(reply);
+      await this.payments.handleWebhookEvent(params.id, "captured");
+      reply.redirect(appendStatusParam(body.returnUrl ?? "/", "success"), 302);
+    },
+  });
+
+  public readonly mockCheckoutCancel = $route({
+    method: "POST",
+    path: `${this.url}/:id/cancel`,
+    schema: {
+      params: t.object({ id: t.uuid() }),
+      body: t.object({ returnUrl: t.optional(t.text({ size: "rich" })) }),
+    },
+    handler: async ({ params, body, reply }) => {
+      if (!this.isMemoryProvider()) return this.forbidden(reply);
+      await this.payments.handleWebhookEvent(params.id, "failed");
+      reply.redirect(appendStatusParam(body.returnUrl ?? "/", "cancel"), 302);
+    },
+  });
+}

package/src/api/payments/index.ts

@@ -1,5 +1,6 @@
 import { $module } from "alepha";
 import { AdminPaymentController } from "./controllers/AdminPaymentController.ts";
+import { MockCheckoutController } from "./controllers/MockCheckoutController.ts";
 import { PaymentController } from "./controllers/PaymentController.ts";
 import { MemoryPaymentProvider } from "./providers/MemoryPaymentProvider.ts";
 import { PaymentProvider } from "./providers/PaymentProvider.ts";
@@ -7,6 +8,7 @@ import { PaymentMethodService } from "./services/PaymentMethodService.ts";
 import { PaymentService } from "./services/PaymentService.ts";
 
 export * from "./controllers/AdminPaymentController.ts";
+export * from "./controllers/MockCheckoutController.ts";
 export * from "./controllers/PaymentController.ts";
 export * from "./entities/paymentIntents.ts";
 export * from "./entities/paymentMethods.ts";
@@ -67,6 +69,7 @@ export const AlephaApiPayments = $module({
   services: [
     AdminPaymentController,
     PaymentController,
+    MockCheckoutController,
     PaymentProvider,
     PaymentService,
     PaymentMethodService,

package/src/api/payments/providers/MemoryPaymentProvider.ts

@@ -29,7 +29,12 @@ export class MemoryPaymentProvider implements PaymentProvider {
 
   public async createSession(
     intent: PaymentIntentEntity,
-    options: { returnUrl: string; authorize?: boolean },
+    options: {
+      returnUrl: string;
+      authorize?: boolean;
+      stripeAccount?: string;
+      applicationFeeAmount?: number;
+    },
   ): Promise<CreateSessionResult> {
     const providerRef = `mem_session_${randomUUID()}`;
     const status = options.authorize ? "authorized" : "captured";
@@ -39,7 +44,7 @@ export class MemoryPaymentProvider implements PaymentProvider {
       status,
     });
     return {
-      url: `/payments/mock-checkout/${intent.id}`,
+      url: `/payments/mock-checkout/${intent.id}?returnUrl=${encodeURIComponent(options.returnUrl)}`,
       providerRef,
     };
   }
@@ -88,8 +93,8 @@ export class MemoryPaymentProvider implements PaymentProvider {
   }
 
   public async createPaymentMethod(
-    userId: string,
-    token: string,
+    _userId: string,
+    _token: string,
   ): Promise<CreatePaymentMethodResult> {
     const providerRef = `mem_pm_${randomUUID()}`;
     const result: CreatePaymentMethodResult = {