@tokenoftrust/storefront-runner 2.4.53 → 2.4.55

package/apps/storefront/src/lib/apps/orders/ordersStore.ts

@@ -10,7 +10,22 @@
  * `AppRegistryService` uses, so this runs unchanged against real D1 in the
  * Worker and an in-memory `node:sqlite` in tests.
  */
-import type { Queryable } from "../../d1/catalog.js";
+import type { Queryable, QueryStatement } from "../../d1/catalog.js";
+import {
+  canonicalJson,
+  idempotencyKey,
+  paginateOrders,
+  sha256Hex,
+  type CommerceStage,
+  type PaymentState,
+} from "@tot/public-runtime";
+import {
+  foldCommerceEvents,
+  packCommercePayload,
+  type CommerceSnapshot,
+  type CommerceSourceEvent,
+  type StoredCommercePayload,
+} from "./orderMapper.js";
 
 export type OrderStatus = "created" | "fulfilled" | "refunded" | "cancelled";
 
@@ -179,3 +194,318 @@ export class OrdersStore {
     return row ? toDomain(row) : null;
   }
 }
+
+interface CommerceOrderRow {
+  tenant_id: string;
+  stage: string;
+  order_id: string;
+  source: string;
+  source_order_id: string;
+  currency: string;
+  placed_at: string;
+  payment_state: PaymentState;
+  compliance_state: CommerceSnapshot["compliance"];
+  stock_state: CommerceSnapshot["stock"];
+  fulfillment_state: CommerceSnapshot["fulfillment"];
+  label_state: CommerceSnapshot["label"];
+  amount_minor: number;
+  event_version: number;
+}
+
+export interface CommerceOrderQueryRow {
+  id: string;
+  placedAt: string;
+  payment: PaymentState;
+  fulfillment: CommerceSnapshot["fulfillment"];
+  amountMinor: number;
+  eventVersion: number;
+}
+
+export interface CommerceAggregate {
+  count: number;
+  amountMinor: number;
+  byPayment: Partial<Record<PaymentState, number>>;
+}
+
+export interface CommitCommerceInput {
+  tenantId: string;
+  stage: CommerceStage;
+  event: CommerceSourceEvent;
+  now: string;
+  replay?: { issuer: string; jti: string };
+}
+
+export type CommitCommerceResult =
+  | { ok: true; duplicate: boolean; snapshot: CommerceSnapshot; outboxId: string }
+  | { ok: false; reason: "replay" };
+
+async function atomic(db: Queryable, statements: readonly QueryStatement[]): Promise<void> {
+  if (typeof db.batch === "function") {
+    await db.batch(statements);
+    return;
+  }
+  await db.exec("BEGIN");
+  try {
+    for (const statement of statements) await db.run(statement.sql, ...(statement.params ?? []));
+    await db.exec("COMMIT");
+  } catch (error) {
+    await db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+function constraintTable(error: unknown): string | null {
+  if (!(error instanceof Error)) return null;
+  const match = /scrappy_[a-z_]+/.exec(error.message);
+  return match ? match[0] : null;
+}
+
+/** Durable commerce projection. Order, inbox, outbox, and caller replay commit together. */
+export class ScrappyOrderLedger {
+  constructor(private readonly db: Queryable) {}
+
+  async commit(input: CommitCommerceInput): Promise<CommitCommerceResult> {
+    const { tenantId, stage, event, now } = input;
+    if (input.replay) {
+      const seen = await this.db.first<{ jti: string }>(
+        `SELECT jti FROM scrappy_caller_replay WHERE tenant_id = ? AND stage = ? AND issuer = ? AND jti = ?`,
+        tenantId,
+        stage,
+        input.replay.issuer,
+        input.replay.jti,
+      );
+      if (seen) return { ok: false, reason: "replay" };
+    }
+
+    const existing = await this.db.first<{ outbox_id: string; payload: string }>(
+      `SELECT outbox_id, payload FROM scrappy_commerce_outbox
+        WHERE tenant_id = ? AND stage = ? AND source = ? AND source_event_id = ?`,
+      tenantId,
+      stage,
+      event.source,
+      event.sourceEventId,
+    );
+    if (existing) {
+      if (input.replay) {
+        try {
+          await this.insertReplay(input);
+        } catch (error) {
+          if (constraintTable(error) === "scrappy_caller_replay") return { ok: false, reason: "replay" };
+          throw error;
+        }
+      }
+      const snapshot = await this.readSnapshot(tenantId, stage, event.orderId, event);
+      return { ok: true, duplicate: true, snapshot, outboxId: existing.outbox_id };
+    }
+
+    const priorRows = await this.db.all<{ payload: string }>(
+      `SELECT payload FROM scrappy_commerce_outbox WHERE tenant_id = ? AND stage = ? AND order_id = ?`,
+      tenantId,
+      stage,
+      event.orderId,
+    );
+    const prior: CommerceSourceEvent[] = [];
+    for (const row of priorRows) {
+      const parsed = JSON.parse(row.payload) as StoredCommercePayload;
+      prior.push(parsed.source);
+    }
+    const snapshot = foldCommerceEvents([...prior, event]);
+    const packed = packCommercePayload(event, snapshot);
+    const key = idempotencyKey(tenantId, stage, event.source, event.sourceEventId);
+    const outboxId = (await sha256Hex(key)).slice(0, 32);
+    const digest = await sha256Hex(canonicalJson(event));
+    const statements: QueryStatement[] = [];
+    if (input.replay) {
+      statements.push({
+        sql: `INSERT INTO scrappy_caller_replay (tenant_id, stage, issuer, jti, seen_at) VALUES (?,?,?,?,?)`,
+        params: [tenantId, stage, input.replay.issuer, input.replay.jti, now],
+      });
+    }
+    statements.push(
+      {
+        sql: `INSERT INTO scrappy_commerce_orders (
+                tenant_id, stage, order_id, source, source_order_id, currency, placed_at,
+                payment_state, compliance_state, stock_state, fulfillment_state, label_state,
+                amount_minor, event_version
+              ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+              ON CONFLICT(tenant_id, stage, order_id) DO UPDATE SET
+                source = excluded.source,
+                source_order_id = excluded.source_order_id,
+                currency = excluded.currency,
+                placed_at = excluded.placed_at,
+                payment_state = excluded.payment_state,
+                compliance_state = excluded.compliance_state,
+                stock_state = excluded.stock_state,
+                fulfillment_state = excluded.fulfillment_state,
+                label_state = excluded.label_state,
+                amount_minor = excluded.amount_minor,
+                event_version = excluded.event_version`,
+        params: [
+          tenantId,
+          stage,
+          snapshot.orderId,
+          snapshot.source,
+          snapshot.sourceOrderId,
+          snapshot.currency,
+          snapshot.placedAt,
+          snapshot.payment,
+          snapshot.compliance,
+          snapshot.stock,
+          snapshot.fulfillment,
+          snapshot.label,
+          snapshot.amountMinor,
+          snapshot.eventVersion,
+        ],
+      },
+      {
+        sql: `INSERT INTO scrappy_commerce_inbox (
+                tenant_id, stage, source, source_event_id, event_version, idempotency_key, payload_digest, received_at
+              ) VALUES (?,?,?,?,?,?,?,?)`,
+        params: [tenantId, stage, event.source, event.sourceEventId, event.eventVersion, key, digest, now],
+      },
+      {
+        sql: `INSERT INTO scrappy_commerce_outbox (
+                outbox_id, tenant_id, stage, order_id, source, source_event_id, event_version,
+                event_type, payload, available_at, attempt_count, state
+              ) VALUES (?,?,?,?,?,?,?,?,?,?,0,'pending')`,
+        params: [
+          outboxId,
+          tenantId,
+          stage,
+          snapshot.orderId,
+          event.source,
+          event.sourceEventId,
+          event.eventVersion,
+          "order.observed",
+          JSON.stringify(packed),
+          now,
+        ],
+      },
+    );
+
+    try {
+      await atomic(this.db, statements);
+    } catch (error) {
+      const table = constraintTable(error);
+      if (table === "scrappy_caller_replay") return { ok: false, reason: "replay" };
+      if (table === "scrappy_commerce_inbox" || table === "scrappy_commerce_outbox") {
+        const raced = await this.db.first<{ outbox_id: string }>(
+          `SELECT outbox_id FROM scrappy_commerce_outbox
+            WHERE tenant_id = ? AND stage = ? AND source = ? AND source_event_id = ?`,
+          tenantId,
+          stage,
+          event.source,
+          event.sourceEventId,
+        );
+        if (raced) {
+          const snapshotNow = await this.readSnapshot(tenantId, stage, event.orderId, event);
+          return { ok: true, duplicate: true, snapshot: snapshotNow, outboxId: raced.outbox_id };
+        }
+      }
+      throw error;
+    }
+    return { ok: true, duplicate: false, snapshot, outboxId };
+  }
+
+  async queryOrders(
+    tenantId: string,
+    stage: CommerceStage,
+    limit: number,
+    cursor: string | null,
+  ): Promise<{ orders: CommerceOrderQueryRow[]; nextCursor: string | null; invalidCursor: boolean }> {
+    const rows = await this.db.all<CommerceOrderRow>(
+      `SELECT * FROM scrappy_commerce_orders WHERE tenant_id = ? AND stage = ?`,
+      tenantId,
+      stage,
+    );
+    const orders = rows.map((row) => ({
+      id: row.order_id,
+      placedAt: row.placed_at,
+      payment: row.payment_state,
+      fulfillment: row.fulfillment_state,
+      amountMinor: row.amount_minor,
+      eventVersion: row.event_version,
+    }));
+    return paginateOrders(orders, limit, cursor);
+  }
+
+  async aggregateOrders(tenantId: string, stage: CommerceStage): Promise<CommerceAggregate> {
+    const rows = await this.db.all<{ payment_state: PaymentState; n: number; amount: number | null }>(
+      `SELECT payment_state, COUNT(*) AS n, SUM(amount_minor) AS amount
+         FROM scrappy_commerce_orders WHERE tenant_id = ? AND stage = ?
+        GROUP BY payment_state`,
+      tenantId,
+      stage,
+    );
+    const byPayment: Partial<Record<PaymentState, number>> = {};
+    let count = 0;
+    let amountMinor = 0;
+    for (const row of rows) {
+      const n = Number(row.n);
+      byPayment[row.payment_state] = n;
+      count += n;
+      amountMinor += Number(row.amount ?? 0);
+    }
+    return { count, amountMinor, byPayment };
+  }
+
+  /** Reset one outbox row for this tenant and stage. Does not write another order. */
+  async replayOutbox(tenantId: string, stage: CommerceStage, outboxId: string, now: string): Promise<boolean> {
+    const row = await this.db.first<{ outbox_id: string }>(
+      `SELECT outbox_id FROM scrappy_commerce_outbox WHERE outbox_id = ? AND tenant_id = ? AND stage = ?`,
+      outboxId,
+      tenantId,
+      stage,
+    );
+    if (!row) return false;
+    await this.db.run(
+      `UPDATE scrappy_commerce_outbox
+          SET state = 'pending', available_at = ?, attempt_count = 0
+        WHERE outbox_id = ? AND tenant_id = ? AND stage = ?`,
+      now,
+      outboxId,
+      tenantId,
+      stage,
+    );
+    return true;
+  }
+
+  async readOrder(tenantId: string, stage: CommerceStage, orderId: string): Promise<CommerceOrderRow | null> {
+    return this.db.first<CommerceOrderRow>(
+      `SELECT * FROM scrappy_commerce_orders WHERE tenant_id = ? AND stage = ? AND order_id = ?`,
+      tenantId,
+      stage,
+      orderId,
+    );
+  }
+
+  private async insertReplay(input: CommitCommerceInput): Promise<void> {
+    if (!input.replay) return;
+    await atomic(this.db, [
+      {
+        sql: `INSERT INTO scrappy_caller_replay (tenant_id, stage, issuer, jti, seen_at) VALUES (?,?,?,?,?)`,
+        params: [input.tenantId, input.stage, input.replay.issuer, input.replay.jti, input.now],
+      },
+    ]);
+  }
+
+  private async readSnapshot(
+    tenantId: string,
+    stage: CommerceStage,
+    orderId: string,
+    event: CommerceSourceEvent,
+  ): Promise<CommerceSnapshot> {
+    const rows = await this.db.all<{ payload: string }>(
+      `SELECT payload FROM scrappy_commerce_outbox WHERE tenant_id = ? AND stage = ? AND order_id = ?`,
+      tenantId,
+      stage,
+      orderId,
+    );
+    const events: CommerceSourceEvent[] = [];
+    for (const row of rows) {
+      const parsed = JSON.parse(row.payload) as StoredCommercePayload;
+      if (parsed.source) events.push(parsed.source);
+    }
+    return foldCommerceEvents(events.length > 0 ? events : [event]);
+  }
+}