@cosmicdrift/kumiko-samples 0.338.0 → 0.340.0

package/samples/recipes/workflow-engine/src/postgres-resume-loop.ts

@@ -4,19 +4,23 @@
 //   1. createSuspendedRunFetcher(db, workflowRegistry) — Postgres-backed
 //   2. createInMemorySuspendedRunFetcher(runs) — for unit tests
 //
-// The fetcher extracts the trigger-event snapshot + Q7 fingerprint directly
-// from the suspension event payload (the wait/waitForEvent/retry steps
-// stamp them there), avoiding a per-run lookup against run.started.
+// The fetcher reads the Q7 fingerprint from the suspension event payload and
+// re-loads the trigger event from the event store through the
+// triggerEventRef on the run's own run.started event (no payload copy lives
+// on the run stream).
 
 import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
-import type { WorkflowDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import type { TenantId, WorkflowDefinition } from "@cosmicdrift/kumiko-framework/engine";
 import {
   WORKFLOW_RETRY_SCHEDULED_TYPE,
+  WORKFLOW_RUN_STARTED_TYPE,
   WORKFLOW_WAITING_FOR_EVENT_TYPE,
   WORKFLOW_WAITING_TYPE,
 } from "@cosmicdrift/kumiko-framework/engine";
+import { loadAggregate } from "@cosmicdrift/kumiko-framework/event-store";
 import { selectExpiredSuspensionEvents } from "./db/queries/suspended-runs";
 import type { SuspendableRun } from "./resume-loop";
+import type { TriggerEventRef } from "./workflow-runner";
 
 export type WorkflowRegistry = ReadonlyMap<string, WorkflowDefinition>;
 
@@ -26,6 +30,42 @@ const SUSPEND_EVENT_TYPES = [
   WORKFLOW_RETRY_SCHEDULED_TYPE,
 ] as const;
 
+function isTriggerEventRef(value: unknown): value is TriggerEventRef {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "eventId" in value &&
+    typeof value.eventId === "string" &&
+    "aggregateId" in value &&
+    typeof value.aggregateId === "string" &&
+    "version" in value &&
+    typeof value.version === "number"
+  );
+}
+
+// undefined when the run has no usable reference or the trigger event can no
+// longer be loaded (archived stream): the run is skipped, never resumed on
+// made-up data.
+async function loadTriggerEvent(
+  db: DbRunner,
+  tenantId: TenantId,
+  runId: string,
+): Promise<{ aggregateId: string; type: string; payload: unknown } | undefined> {
+  const runEvents = await loadAggregate(db, runId, tenantId);
+  const started = runEvents.find((e) => e.type === WORKFLOW_RUN_STARTED_TYPE);
+  if (!started) return undefined;
+  const ref = started.payload["triggerEventRef"];
+  if (ref === undefined) {
+    // Cron run: the synthetic trigger event was never stored.
+    return { aggregateId: runId, type: String(started.payload["triggerEventType"]), payload: {} };
+  }
+  if (!isTriggerEventRef(ref)) return undefined;
+  const source = (await loadAggregate(db, ref.aggregateId, tenantId)).find(
+    (e) => e.id === ref.eventId,
+  );
+  return source && { aggregateId: source.aggregateId, type: source.type, payload: source.payload };
+}
+
 /**
  * Postgres-backed fetcher. Queries kumiko_events for suspension events with
  * expired wakeAt/timeoutAt timestamps. The resume-loop applies the Q7
@@ -64,11 +104,12 @@ export function createSuspendedRunFetcher(
       const wakeAt = (payload["wakeAt"] ?? payload["timeoutAt"]) as string | undefined;
       if (!wakeAt) continue;
 
-      const triggerEvent = {
-        aggregateId: (payload["triggerAggregateId"] as string | undefined) ?? aggregateId,
-        type: (payload["triggerEventType"] as string | undefined) ?? "kumiko:system:resume",
-        payload: payload["triggerPayload"] ?? {},
-      };
+      const triggerEvent = await loadTriggerEvent(
+        db,
+        (row["tenantId"] ?? row["tenant_id"]) as TenantId, // @cast-boundary raw-sql-row
+        aggregateId,
+      );
+      if (!triggerEvent) continue;
 
       results.push({
         runId: aggregateId,

package/samples/recipes/workflow-engine/src/workflow-runner.ts

@@ -26,10 +26,19 @@ import {
   WORKFLOW_RUN_STARTED_TYPE,
 } from "@cosmicdrift/kumiko-framework/engine";
 
+// Reference into the event store; the run stream never copies a foreign
+// payload, so erasing the source event also covers the workflow.
+export type TriggerEventRef = {
+  readonly eventId: string;
+  readonly aggregateId: string;
+  readonly version: number;
+};
+
 export type WorkflowRunStartedPayload = {
   readonly workflowName: string;
   readonly triggerEventType: string;
-  readonly triggerPayload: unknown;
+  // Absent for cron runs: their synthetic trigger event has no stored source.
+  readonly triggerEventRef?: TriggerEventRef;
   readonly definitionFingerprint: string;
   readonly idempotencyKey?: string;
 };
@@ -47,6 +56,7 @@ export async function startAndRunWorkflow(args: {
   readonly runId: string;
   readonly workflow: WorkflowDefinition;
   readonly triggerEvent: WriteEvent;
+  readonly triggerEventRef?: TriggerEventRef;
   readonly idempotencyKey?: string;
   readonly handlerCtx: HandlerContext;
 }): Promise<{ readonly outcome: "completed" | "suspended" }> {
@@ -55,7 +65,7 @@ export async function startAndRunWorkflow(args: {
   const startedPayload: WorkflowRunStartedPayload = {
     workflowName: args.workflow.name,
     triggerEventType: args.triggerEvent.type,
-    triggerPayload: args.triggerEvent.payload,
+    ...(args.triggerEventRef && { triggerEventRef: args.triggerEventRef }),
     definitionFingerprint: fingerprint,
     ...(args.idempotencyKey && { idempotencyKey: args.idempotencyKey }),
   };

package/packages/bundled-features/src/billing-foundation/db/queries/payment-projection.ts

@@ -1,19 +0,0 @@
-import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
-import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
-
-// INSERT-once, not UPSERT: unlike subscriptionsProjectionTable (one row per
-// tenant, state overwritten on every event), a payment row is an immutable
-// fact keyed by paymentRowId(tenantId, providerName, providerEventId) — ON
-// CONFLICT DO NOTHING makes a projection rebuild/replay idempotent without
-// ever mutating an existing row.
-export async function insertPaymentProjectionRow(
-  tx: DbRunner,
-  tableName: string,
-  insertCols: Record<string, unknown>,
-): Promise<void> {
-  const insertKeys = Object.keys(insertCols);
-  const insertPlaceholders = insertKeys.map((_, i) => `$${i + 1}`);
-  const sqlText = `INSERT INTO "${tableName}" (${insertKeys.map((k) => `"${k}"`).join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT ("id") DO NOTHING`;
-  // kumiko-lint-ignore raw-sql tableName + column keys are code-controlled, not user input: tableName is buildEntityTable()'s static table name and insertKeys come from applyPaymentReceived's hardcoded object-literal columns in projection.ts — only values flow through $1..$n
-  await asRawClient(tx).unsafe(sqlText, Object.values(insertCols));
-}

package/packages/bundled-features/src/billing-foundation/db/queries/subscription-projection.ts

@@ -1,15 +0,0 @@
-import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
-import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
-
-export async function upsertSubscriptionProjectionRow(
-  tx: DbRunner,
-  tableName: string,
-  insertCols: Record<string, unknown>,
-  setClauses: readonly string[],
-  params: readonly unknown[],
-): Promise<void> {
-  const insertKeys = Object.keys(insertCols);
-  const insertPlaceholders = insertKeys.map((_, i) => `$${i + 1}`);
-  const sqlText = `INSERT INTO "${tableName}" (${insertKeys.map((k) => `"${k}"`).join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT ("id") DO UPDATE SET ${setClauses.join(", ")}`;
-  await asRawClient(tx).unsafe(sqlText, params);
-}

package/packages/bundled-features/src/inbound-mail-foundation/db/queries/inbound-projections.ts

@@ -1,38 +0,0 @@
-// Raw-SQL-Helper für die inline projections — Muster
-// billing-foundation/db/queries/subscription-projection.ts.
-//
-// Warum raw statt drizzle-insert: die apply-fns laufen in der event-TX
-// mit einem DbRunner, und die ON-CONFLICT-Semantik (UPSERT vs.
-// DO NOTHING) ist der fachliche Kern — explizit hingeschrieben statt
-// hinter einem ORM-Builder versteckt.
-
-import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
-import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
-
-/** INSERT ... ON CONFLICT ("id") DO UPDATE SET <setClauses>. */
-export async function upsertProjectionRow(
-  tx: DbRunner,
-  tableName: string,
-  insertCols: Record<string, unknown>,
-  setClauses: readonly string[],
-  params: readonly unknown[],
-): Promise<void> {
-  const insertKeys = Object.keys(insertCols);
-  const insertPlaceholders = insertKeys.map((_, i) => `$${i + 1}`);
-  const sqlText = `INSERT INTO "${tableName}" (${insertKeys.map((k) => `"${k}"`).join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT ("id") DO UPDATE SET ${setClauses.join(", ")}`;
-  await asRawClient(tx).unsafe(sqlText, params);
-}
-
-/** INSERT ... ON CONFLICT ("id") DO NOTHING — für append-only-Rows
- *  (inbound-message: genau EIN received-event pro Stream, Replays
- *  no-op'en auf der PK). */
-export async function insertIgnoreProjectionRow(
-  tx: DbRunner,
-  tableName: string,
-  insertCols: Record<string, unknown>,
-): Promise<void> {
-  const insertKeys = Object.keys(insertCols);
-  const insertPlaceholders = insertKeys.map((_, i) => `$${i + 1}`);
-  const sqlText = `INSERT INTO "${tableName}" (${insertKeys.map((k) => `"${k}"`).join(", ")}) VALUES (${insertPlaceholders.join(", ")}) ON CONFLICT ("id") DO NOTHING`;
-  await asRawClient(tx).unsafe(sqlText, Object.values(insertCols));
-}