@dudousxd/nestjs-durable-store-drizzle 0.16.0 → 0.17.0

package/dist/pg/index.js

@@ -0,0 +1,754 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/pg/ddl.ts
+import { sql } from "drizzle-orm";
+var DURABLE_PG_DDL = [
+  `CREATE TABLE IF NOT EXISTS "durable_workflow_runs" (
+  "id" text PRIMARY KEY NOT NULL,
+  "workflow" text NOT NULL,
+  "workflow_version" text NOT NULL,
+  "status" text NOT NULL,
+  "input" jsonb,
+  "output" jsonb,
+  "error" jsonb,
+  "wake_at" timestamp with time zone,
+  "locked_by" text,
+  "locked_until" timestamp with time zone,
+  "awaiting_decision_task_id" text,
+  "recovery_attempts" integer,
+  "tags" jsonb,
+  "search_attributes" jsonb,
+  "priority" integer,
+  "namespace" text DEFAULT 'default' NOT NULL,
+  "origin" text,
+  "created_at" timestamp with time zone NOT NULL,
+  "updated_at" timestamp with time zone NOT NULL
+)`,
+  `CREATE TABLE IF NOT EXISTS "durable_step_checkpoints" (
+  "run_id" text NOT NULL,
+  "seq" integer NOT NULL,
+  "name" text NOT NULL,
+  "kind" text NOT NULL,
+  "step_id" text NOT NULL,
+  "status" text NOT NULL,
+  "input" jsonb,
+  "output" jsonb,
+  "error" jsonb,
+  "events" jsonb,
+  "attempts" integer NOT NULL,
+  "worker_group" text,
+  "parallel_group" text,
+  "wake_at" timestamp with time zone,
+  "enqueued_at" timestamp with time zone,
+  "started_at" timestamp with time zone NOT NULL,
+  "finished_at" timestamp with time zone NOT NULL,
+  CONSTRAINT "durable_step_checkpoints_run_id_seq_pk" PRIMARY KEY("run_id","seq")
+)`,
+  `CREATE TABLE IF NOT EXISTS "durable_run_attributes" (
+  "run_id" text NOT NULL,
+  "key" text NOT NULL,
+  "str_value" text,
+  "num_value" double precision,
+  CONSTRAINT "durable_run_attributes_run_id_key_pk" PRIMARY KEY("run_id","key")
+)`,
+  `CREATE TABLE IF NOT EXISTS "durable_signal_waiters" (
+  "token" text PRIMARY KEY NOT NULL,
+  "run_id" text NOT NULL,
+  "seq" integer NOT NULL,
+  "parallel_group" text
+)`,
+  `CREATE TABLE IF NOT EXISTS "durable_buffered_signals" (
+  "id" bigserial PRIMARY KEY NOT NULL,
+  "token" text NOT NULL,
+  "payload" jsonb
+)`,
+  `CREATE TABLE IF NOT EXISTS "durable_buffered_events" (
+  "id" text PRIMARY KEY NOT NULL,
+  "name" text NOT NULL,
+  "payload" jsonb,
+  "published_at" timestamp with time zone NOT NULL
+)`,
+  `CREATE INDEX IF NOT EXISTS "durable_runs_status_idx" ON "durable_workflow_runs" USING btree ("status","wake_at")`,
+  `CREATE INDEX IF NOT EXISTS "durable_runs_workflow_status_idx" ON "durable_workflow_runs" USING btree ("workflow","status")`,
+  `CREATE INDEX IF NOT EXISTS "durable_workflow_runs_namespace_status_idx" ON "durable_workflow_runs" USING btree ("namespace","status","created_at")`,
+  `CREATE INDEX IF NOT EXISTS "durable_runs_tags_gin_idx" ON "durable_workflow_runs" USING gin ("tags" jsonb_path_ops)`,
+  `CREATE INDEX IF NOT EXISTS "durable_runs_status_updated_idx" ON "durable_workflow_runs" USING btree ("status","updated_at")`,
+  `CREATE INDEX IF NOT EXISTS "durable_run_attributes_num_idx" ON "durable_run_attributes" USING btree ("key","num_value")`,
+  `CREATE INDEX IF NOT EXISTS "durable_run_attributes_str_idx" ON "durable_run_attributes" USING btree ("key","str_value")`,
+  `CREATE INDEX IF NOT EXISTS "durable_signal_waiters_run_id_idx" ON "durable_signal_waiters" USING btree ("run_id")`,
+  `CREATE INDEX IF NOT EXISTS "durable_buffered_signals_token_idx" ON "durable_buffered_signals" USING btree ("token","id")`,
+  `CREATE INDEX IF NOT EXISTS "durable_buffered_events_name_published_at_idx" ON "durable_buffered_events" USING btree ("name","published_at")`
+];
+var SCHEMA_LOCK_KEY = "durable_schema";
+async function ensureDrizzlePgDurableSchema(db) {
+  await db.transaction(async (tx) => {
+    await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${SCHEMA_LOCK_KEY}))`);
+    for (const statement of DURABLE_PG_DDL) await tx.execute(sql.raw(statement));
+  });
+}
+__name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
+
+// src/pg/drizzle-pg-state-store.ts
+import { RUN_VALUE_FACET_SCAN, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns } from "@dudousxd/nestjs-durable-core";
+import { and, asc, desc, eq, exists, inArray, isNotNull, isNull, like, lt, lte, or, sql as sql2 } from "drizzle-orm";
+
+// src/pg/schema.ts
+import { getTableName } from "drizzle-orm";
+import { bigserial, doublePrecision, index, integer, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
+var DEFAULT_NAMESPACE = "default";
+var tstz = /* @__PURE__ */ __name((name) => timestamp(name, {
+  withTimezone: true,
+  mode: "date"
+}), "tstz");
+var durableWorkflowRuns = pgTable("durable_workflow_runs", {
+  id: text("id").primaryKey(),
+  workflow: text("workflow").notNull(),
+  workflowVersion: text("workflow_version").notNull(),
+  status: text("status").notNull(),
+  input: jsonb("input"),
+  output: jsonb("output"),
+  error: jsonb("error"),
+  wakeAt: tstz("wake_at"),
+  lockedBy: text("locked_by"),
+  lockedUntil: tstz("locked_until"),
+  // REMOTE turn the engine suspended on awaiting a decision; matched by completeRemoteDecision so
+  // only the currently-awaited turn's decision is applied. Nullable: cleared when a decision lands.
+  awaitingDecisionTaskId: text("awaiting_decision_task_id"),
+  recoveryAttempts: integer("recovery_attempts"),
+  tags: jsonb("tags").$type(),
+  searchAttributes: jsonb("search_attributes").$type(),
+  priority: integer("priority"),
+  // The worker-pool partition (tenant) — THE isolation boundary every poll predicate filters on.
+  // NOT NULL DEFAULT 'default' so a row can never fall outside every worker's namespace.
+  namespace: text("namespace").notNull().default(DEFAULT_NAMESPACE),
+  // Which package declared the workflow. Nullable, no default: NULL = unknown, never guessed.
+  origin: text("origin"),
+  createdAt: tstz("created_at").notNull(),
+  updatedAt: tstz("updated_at").notNull()
+}, (t) => [
+  // Timer poller (`listDueTimers`) + recovery (`listIncompleteRuns`). Same name as the TypeORM DDL.
+  index("durable_runs_status_idx").on(t.status, t.wakeAt),
+  // Dashboard `listRuns({ workflow, status })` and the singleton gate's per-workflow scans.
+  index("durable_runs_workflow_status_idx").on(t.workflow, t.status),
+  // Every namespaced poll tick: `namespace = $1 AND status = $2 ORDER BY created_at` (FIFO pick-up).
+  // Name matches the MikroORM adapter + the SQLite drizzle schema so a store swap keeps the index.
+  index("durable_workflow_runs_namespace_status_idx").on(t.namespace, t.status, t.createdAt),
+  // `listRuns({ tag })` compiles to `tags @> '["tag"]'`, which a `jsonb_path_ops` GIN index serves —
+  // this is what keeps the singleton gate (`tag: singleton:<key>`, e.g. a per-tenant concurrency
+  // key) an index probe instead of a scan of every run the workflow ever had.
+  index("durable_runs_tags_gin_idx").using("gin", t.tags.op("jsonb_path_ops")),
+  // Retention (`pruneTerminalRuns`) orders a status set by `updated_at`.
+  index("durable_runs_status_updated_idx").on(t.status, t.updatedAt)
+]);
+var durableStepCheckpoints = pgTable(
+  "durable_step_checkpoints",
+  {
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    name: text("name").notNull(),
+    kind: text("kind").notNull(),
+    stepId: text("step_id").notNull(),
+    status: text("status").notNull(),
+    input: jsonb("input"),
+    output: jsonb("output"),
+    error: jsonb("error"),
+    events: jsonb("events"),
+    attempts: integer("attempts").notNull(),
+    workerGroup: text("worker_group"),
+    parallelGroup: text("parallel_group"),
+    wakeAt: tstz("wake_at"),
+    enqueuedAt: tstz("enqueued_at"),
+    startedAt: tstz("started_at").notNull(),
+    finishedAt: tstz("finished_at").notNull()
+  },
+  // (run_id, seq) is the primary key, so listCheckpoints / getEvent already hit an index.
+  (t) => [
+    primaryKey({
+      columns: [
+        t.runId,
+        t.seq
+      ]
+    })
+  ]
+);
+var durableRunAttributes = pgTable("durable_run_attributes", {
+  runId: text("run_id").notNull(),
+  key: text("key").notNull(),
+  strValue: text("str_value"),
+  numValue: doublePrecision("num_value")
+}, (t) => [
+  primaryKey({
+    columns: [
+      t.runId,
+      t.key
+    ]
+  }),
+  index("durable_run_attributes_num_idx").on(t.key, t.numValue),
+  index("durable_run_attributes_str_idx").on(t.key, t.strValue)
+]);
+var durableSignalWaiters = pgTable(
+  "durable_signal_waiters",
+  {
+    token: text("token").primaryKey(),
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    parallelGroup: text("parallel_group")
+  },
+  // deleteRun / pruneTerminalRuns delete a run's waiters by run_id.
+  (t) => [
+    index("durable_signal_waiters_run_id_idx").on(t.runId)
+  ]
+);
+var durableBufferedSignals = pgTable(
+  "durable_buffered_signals",
+  {
+    id: bigserial("id", {
+      mode: "number"
+    }).primaryKey(),
+    token: text("token").notNull(),
+    payload: jsonb("payload")
+  },
+  // Taken FIFO per token (smallest id first).
+  (t) => [
+    index("durable_buffered_signals_token_idx").on(t.token, t.id)
+  ]
+);
+var durableBufferedEvents = pgTable("durable_buffered_events", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  payload: jsonb("payload"),
+  publishedAt: tstz("published_at").notNull()
+}, (t) => [
+  index("durable_buffered_events_name_published_at_idx").on(t.name, t.publishedAt)
+]);
+var durablePgSchema = {
+  durableWorkflowRuns,
+  durableStepCheckpoints,
+  durableRunAttributes,
+  durableSignalWaiters,
+  durableBufferedSignals,
+  durableBufferedEvents
+};
+function durablePgManagedTables() {
+  return Object.values(durablePgSchema).map((table) => getTableName(table));
+}
+__name(durablePgManagedTables, "durablePgManagedTables");
+
+// src/pg/drizzle-pg-state-store.ts
+function anyOf(conditions) {
+  const present = conditions.filter((c) => c !== void 0);
+  return present.length ? or(...present) : sql2`1 = 0`;
+}
+__name(anyOf, "anyOf");
+function namespaceFilter(namespace) {
+  return namespace === void 0 ? void 0 : eq(durableWorkflowRuns.namespace, namespace);
+}
+__name(namespaceFilter, "namespaceFilter");
+function hasTag(tag) {
+  return sql2`${durableWorkflowRuns.tags} @> ${JSON.stringify([
+    tag
+  ])}::jsonb`;
+}
+__name(hasTag, "hasTag");
+var date = /* @__PURE__ */ __name((ms2) => ms2 == null ? null : new Date(ms2), "date");
+var ms = /* @__PURE__ */ __name((d) => d == null ? void 0 : d.getTime(), "ms");
+var DrizzlePgStateStore = class _DrizzlePgStateStore {
+  static {
+    __name(this, "DrizzlePgStateStore");
+  }
+  db;
+  options;
+  scopeNamespace;
+  constructor(db, options = {}) {
+    this.db = db;
+    this.options = options;
+    this.scopeNamespace = options.scope?.namespace;
+  }
+  /** A store confined to `scope.namespace`, sharing this store's db (no new connection). Used by the
+  *  NestJS module's `scopeReads`; `{ namespace: undefined }` is the unscoped operator view. */
+  withScope(scope) {
+    return new _DrizzlePgStateStore(this.db, {
+      ...this.options,
+      scope
+    });
+  }
+  /** Idempotent CREATE TABLE / INDEX IF NOT EXISTS under an advisory lock — called on boot when the
+  *  module's `autoSchema` is on. Turn `autoSchema` off if drizzle-kit owns these tables. */
+  async ensureSchema() {
+    await ensureDrizzlePgDurableSchema(this.db);
+  }
+  /** The read-scope predicate on the runs table (undefined when the store is unscoped). */
+  scope() {
+    return namespaceFilter(this.scopeNamespace);
+  }
+  async createRun(run) {
+    await this.db.transaction(async (tx) => {
+      await tx.insert(durableWorkflowRuns).values(toRunRow(run));
+      await reindexAttributes(tx, run.id, run.searchAttributes);
+    });
+  }
+  async updateRun(runId, patch) {
+    const row = toRunPatch(patch);
+    const reindex = "searchAttributes" in patch;
+    if (!Object.keys(row).length && !reindex) return;
+    await this.db.transaction(async (tx) => {
+      if (Object.keys(row).length) await tx.update(durableWorkflowRuns).set(row).where(eq(durableWorkflowRuns.id, runId));
+      if (reindex) await reindexAttributes(tx, runId, patch.searchAttributes);
+    });
+  }
+  async getRun(runId) {
+    const rows = await this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.id, runId), this.scope())).limit(1);
+    return rows[0] ? fromRunRow(rows[0]) : null;
+  }
+  async deleteRun(runId) {
+    await this.db.transaction(async (tx) => {
+      await deleteRunsCascade(tx, [
+        runId
+      ]);
+    });
+  }
+  async pruneTerminalRuns(policy, nowMs, limit) {
+    const statuses = policy.statuses.filter((s) => TERMINAL_RUN_STATUSES.includes(s));
+    if (statuses.length === 0 || limit <= 0) return 0;
+    if (policy.maxAge == null && policy.maxCount == null) return 0;
+    return this.db.transaction(async (tx) => {
+      const ids = /* @__PURE__ */ new Set();
+      if (policy.maxAge != null) {
+        const cutoff = new Date(nowMs - parseDuration(policy.maxAge));
+        const rows = await tx.select({
+          id: durableWorkflowRuns.id
+        }).from(durableWorkflowRuns).where(and(inArray(durableWorkflowRuns.status, statuses), lt(durableWorkflowRuns.updatedAt, cutoff))).orderBy(asc(durableWorkflowRuns.updatedAt)).limit(limit).for("update", {
+          skipLocked: true
+        });
+        for (const r of rows) ids.add(r.id);
+      }
+      if (policy.maxCount != null && ids.size < limit) {
+        const rows = await tx.select({
+          id: durableWorkflowRuns.id
+        }).from(durableWorkflowRuns).where(inArray(durableWorkflowRuns.status, statuses)).orderBy(desc(durableWorkflowRuns.updatedAt), desc(durableWorkflowRuns.id)).limit(limit).offset(policy.maxCount).for("update", {
+          skipLocked: true
+        });
+        for (const r of rows) {
+          if (ids.size >= limit) break;
+          ids.add(r.id);
+        }
+      }
+      if (ids.size === 0) return 0;
+      const idList = [
+        ...ids
+      ].slice(0, limit);
+      await deleteRunsCascade(tx, idList);
+      return idList.length;
+    });
+  }
+  async getCheckpoint(runId, seq) {
+    const rows = await this.db.select().from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), eq(durableStepCheckpoints.seq, seq))).limit(1);
+    return rows[0] ? fromCheckpointRow(rows[0]) : null;
+  }
+  async saveCheckpoint(checkpoint) {
+    await upsertCheckpoint(this.db, checkpoint);
+  }
+  async transaction(work) {
+    return this.db.transaction(async (tx) => work({
+      raw: tx,
+      saveCheckpoint: /* @__PURE__ */ __name((cp) => upsertCheckpoint(tx, cp), "saveCheckpoint")
+    }));
+  }
+  /** Crash recovery. Namespace-scoped: a worker re-drives only its own tenant's runs. */
+  async listIncompleteRuns(namespace) {
+    const rows = await this.db.select().from(durableWorkflowRuns).where(and(inArray(durableWorkflowRuns.status, [
+      "running",
+      "cancelling"
+    ]), namespaceFilter(namespace), this.scope()));
+    return rows.map(fromRunRow);
+  }
+  /** FIFO pick-up, served by `durable_workflow_runs_namespace_status_idx`. The engine then leases
+  *  each run with {@link tryLockRun}; the listing itself takes no locks (it runs outside a tx). */
+  async listPendingRuns(limit, namespace) {
+    const rows = await this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.status, "pending"), namespaceFilter(namespace), this.scope())).orderBy(asc(durableWorkflowRuns.createdAt)).limit(limit);
+    return rows.map(fromRunRow);
+  }
+  async listDueTimers(nowMs, namespace) {
+    const rows = await this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.status, "suspended"), isNotNull(durableWorkflowRuns.wakeAt), lte(durableWorkflowRuns.wakeAt, new Date(nowMs)), namespaceFilter(namespace), this.scope()));
+    return rows.map(fromRunRow);
+  }
+  async tryLockRun(runId, owner, leaseUntilMs, nowMs) {
+    const rows = await this.db.update(durableWorkflowRuns).set({
+      lockedBy: owner,
+      lockedUntil: new Date(leaseUntilMs)
+    }).where(and(eq(durableWorkflowRuns.id, runId), or(isNull(durableWorkflowRuns.lockedUntil), lte(durableWorkflowRuns.lockedUntil, new Date(nowMs))))).returning({
+      id: durableWorkflowRuns.id
+    });
+    return rows.length === 1;
+  }
+  async releaseRunLock(runId) {
+    await this.db.update(durableWorkflowRuns).set({
+      lockedBy: null,
+      lockedUntil: null
+    }).where(eq(durableWorkflowRuns.id, runId));
+  }
+  async renewRunLock(runId, owner, leaseUntilMs) {
+    const rows = await this.db.update(durableWorkflowRuns).set({
+      lockedUntil: new Date(leaseUntilMs)
+    }).where(and(eq(durableWorkflowRuns.id, runId), eq(durableWorkflowRuns.lockedBy, owner))).returning({
+      id: durableWorkflowRuns.id
+    });
+    return rows.length === 1;
+  }
+  /** The predicates every run query shares — {@link listRuns} pages them, the facets group them. */
+  runFilters(query) {
+    return [
+      this.scope(),
+      query.workflow ? eq(durableWorkflowRuns.workflow, query.workflow) : void 0,
+      query.workflows ? query.workflows.length ? inArray(durableWorkflowRuns.workflow, query.workflows) : sql2`1 = 0` : void 0,
+      // The tenant boundary. Also the engine's execution-timeout sweep path
+      // (`listRuns({ workflow, status, namespace })`) — unscoped, it would cancel another tenant's runs.
+      namespaceFilter(query.namespace),
+      query.namespaces ? query.namespaces.length ? inArray(durableWorkflowRuns.namespace, query.namespaces) : sql2`1 = 0` : void 0,
+      // `null` selects the unattributed bucket; a value never matches a NULL origin.
+      query.origin === null ? isNull(durableWorkflowRuns.origin) : query.origin !== void 0 ? eq(durableWorkflowRuns.origin, query.origin) : void 0,
+      query.origins ? anyOf(query.origins.map((o) => o === null ? isNull(durableWorkflowRuns.origin) : eq(durableWorkflowRuns.origin, o))) : void 0,
+      query.status ? eq(durableWorkflowRuns.status, query.status) : void 0,
+      query.statuses ? query.statuses.length ? inArray(durableWorkflowRuns.status, query.statuses) : sql2`1 = 0` : void 0,
+      query.tag ? hasTag(query.tag) : void 0,
+      query.tags ? anyOf(query.tags.map(hasTag)) : void 0,
+      // One EXISTS per attribute predicate against the normalized side table (ANDed).
+      ...query.attributes?.map((f) => this.attributeExists(f)) ?? []
+    ].filter((f) => f !== void 0);
+  }
+  async listRuns(query) {
+    const filters = this.runFilters(query);
+    const base = this.db.select().from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0).orderBy(desc(durableWorkflowRuns.createdAt), desc(durableWorkflowRuns.id)).$dynamic();
+    if (query.limit != null) base.limit(query.limit);
+    if (query.offset != null) base.offset(query.offset);
+    const rows = await base;
+    return rows.map(fromRunRow);
+  }
+  async runFacets(query) {
+    const filters = this.runFilters(query);
+    const rows = await this.db.select({
+      status: durableWorkflowRuns.status,
+      origin: durableWorkflowRuns.origin,
+      count: sql2`count(*)`.mapWith(Number)
+    }).from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0).groupBy(durableWorkflowRuns.status, durableWorkflowRuns.origin);
+    return mergeRunFacetRows(rows.map((r) => ({
+      status: r.status,
+      origin: r.origin,
+      count: r.count
+    })));
+  }
+  /** Run-table axes are an exact `GROUP BY`; the tag / attribute axes are counted over a bounded
+  *  page of runs (see `RunValueFacetOptions.scan`), like the TypeORM and SQLite Drizzle adapters. */
+  async runValueFacets(axis, query, opts) {
+    if (!axisIsRunColumn(axis)) {
+      const runs = await this.listRuns({
+        ...query,
+        limit: opts?.scan ?? RUN_VALUE_FACET_SCAN
+      });
+      return runValueFacetsFromRuns(runs, axis, opts);
+    }
+    const column = durableWorkflowRuns[axis.field];
+    const filters = this.runFilters(query);
+    const rows = await this.db.select({
+      value: column,
+      count: sql2`count(*)`.mapWith(Number)
+    }).from(durableWorkflowRuns).where(filters.length ? and(...filters) : void 0).groupBy(column);
+    return mergeRunValueFacetRows(rows.map((r) => ({
+      value: r.value ?? null,
+      count: r.count
+    })), opts);
+  }
+  /** One attribute predicate as an EXISTS on the side table, correlated to the outer run. `ne` also
+  *  excludes runs lacking the key (EXISTS requires the row). Numbers compare `num_value`, strings
+  *  and booleans `str_value`; an `in` set ORs its members inside the one EXISTS. */
+  attributeExists(f) {
+    const comparisons = attributePredicateOperands(f).map(({ column, comparator, operand }) => sql2`${column === "numValue" ? durableRunAttributes.numValue : durableRunAttributes.strValue} ${sql2.raw(comparator)} ${operand}`);
+    return exists(this.db.select({
+      one: sql2`1`
+    }).from(durableRunAttributes).where(and(eq(durableRunAttributes.runId, durableWorkflowRuns.id), eq(durableRunAttributes.key, f.key), anyOf(comparisons))));
+  }
+  async listCheckpoints(runId) {
+    const rows = await this.db.select().from(durableStepCheckpoints).where(eq(durableStepCheckpoints.runId, runId)).orderBy(asc(durableStepCheckpoints.seq));
+    return rows.map(fromCheckpointRow);
+  }
+  async getLatestCheckpointByName(runId, name) {
+    const rows = await this.db.select().from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), eq(durableStepCheckpoints.name, name))).orderBy(desc(durableStepCheckpoints.seq)).limit(1);
+    return rows[0] ? fromCheckpointRow(rows[0]) : void 0;
+  }
+  async listCheckpointsByNamePrefix(runId, prefixes) {
+    if (prefixes.length === 0) return [];
+    const rows = await this.db.select().from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), or(...prefixes.map((p) => like(durableStepCheckpoints.name, `${escapeLike(p)}%`))))).orderBy(asc(durableStepCheckpoints.seq));
+    return rows.map(fromCheckpointRow);
+  }
+  async putSignalWaiter(waiter) {
+    const set = {
+      runId: waiter.runId,
+      seq: waiter.seq,
+      parallelGroup: waiter.parallelGroup ?? null
+    };
+    await this.db.insert(durableSignalWaiters).values({
+      token: waiter.token,
+      ...set
+    }).onConflictDoUpdate({
+      target: durableSignalWaiters.token,
+      set
+    });
+  }
+  async takeSignalWaiter(token) {
+    const rows = await this.db.delete(durableSignalWaiters).where(eq(durableSignalWaiters.token, token)).returning();
+    const row = rows[0];
+    return row ? fromWaiterRow(row) : null;
+  }
+  async listSignalWaiters(prefix) {
+    const rows = await this.db.select().from(durableSignalWaiters).where(like(durableSignalWaiters.token, `${escapeLike(prefix)}%`));
+    return rows.map(fromWaiterRow);
+  }
+  async removeSignalWaiter(waiter) {
+    await this.db.delete(durableSignalWaiters).where(and(eq(durableSignalWaiters.token, waiter.token), eq(durableSignalWaiters.runId, waiter.runId), eq(durableSignalWaiters.seq, waiter.seq)));
+  }
+  async bufferSignal(token, payload) {
+    await this.db.insert(durableBufferedSignals).values({
+      token,
+      payload: payload ?? null
+    });
+  }
+  async takeBufferedSignal(token) {
+    const oldest = this.db.select({
+      id: durableBufferedSignals.id
+    }).from(durableBufferedSignals).where(eq(durableBufferedSignals.token, token)).orderBy(asc(durableBufferedSignals.id)).limit(1).for("update", {
+      skipLocked: true
+    });
+    const rows = await this.db.delete(durableBufferedSignals).where(inArray(durableBufferedSignals.id, oldest)).returning({
+      payload: durableBufferedSignals.payload
+    });
+    const row = rows[0];
+    return row ? {
+      payload: row.payload ?? void 0
+    } : null;
+  }
+  async bufferEvent(input) {
+    await this.db.insert(durableBufferedEvents).values({
+      id: input.id,
+      name: input.name,
+      payload: input.payload ?? null,
+      publishedAt: new Date(input.publishedAt)
+    });
+  }
+  async listBufferedEvents(name, limit) {
+    const rows = await this.db.select().from(durableBufferedEvents).where(eq(durableBufferedEvents.name, name)).orderBy(asc(durableBufferedEvents.publishedAt), asc(durableBufferedEvents.id)).limit(limit);
+    return rows.map((r) => ({
+      id: r.id,
+      payload: r.payload ?? void 0,
+      publishedAt: r.publishedAt.getTime()
+    }));
+  }
+  async removeBufferedEvent(id) {
+    const rows = await this.db.delete(durableBufferedEvents).where(eq(durableBufferedEvents.id, id)).returning({
+      id: durableBufferedEvents.id
+    });
+    return rows.length === 1;
+  }
+};
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+__name(escapeLike, "escapeLike");
+async function upsertCheckpoint(db, cp) {
+  const row = toCheckpointRow(cp);
+  await db.insert(durableStepCheckpoints).values(row).onConflictDoUpdate({
+    target: [
+      durableStepCheckpoints.runId,
+      durableStepCheckpoints.seq
+    ],
+    set: row
+  });
+}
+__name(upsertCheckpoint, "upsertCheckpoint");
+async function reindexAttributes(db, runId, attributes) {
+  await db.delete(durableRunAttributes).where(eq(durableRunAttributes.runId, runId));
+  const rows = normalizeAttributeRows(runId, attributes);
+  if (rows.length) await db.insert(durableRunAttributes).values(rows);
+}
+__name(reindexAttributes, "reindexAttributes");
+async function deleteRunsCascade(db, runIds) {
+  await db.delete(durableStepCheckpoints).where(inArray(durableStepCheckpoints.runId, runIds));
+  await db.delete(durableSignalWaiters).where(inArray(durableSignalWaiters.runId, runIds));
+  await db.delete(durableRunAttributes).where(inArray(durableRunAttributes.runId, runIds));
+  await db.delete(durableWorkflowRuns).where(inArray(durableWorkflowRuns.id, runIds));
+}
+__name(deleteRunsCascade, "deleteRunsCascade");
+function fromWaiterRow(row) {
+  return {
+    token: row.token,
+    runId: row.runId,
+    seq: row.seq,
+    parallelGroup: row.parallelGroup ?? void 0
+  };
+}
+__name(fromWaiterRow, "fromWaiterRow");
+function toRunRow(run) {
+  return {
+    id: run.id,
+    workflow: run.workflow,
+    workflowVersion: run.workflowVersion,
+    status: run.status,
+    input: run.input ?? null,
+    output: run.output ?? null,
+    error: run.error ?? null,
+    wakeAt: date(run.wakeAt),
+    lockedBy: run.lockedBy ?? null,
+    lockedUntil: date(run.lockedUntil),
+    awaitingDecisionTaskId: run.awaitingDecisionTaskId ?? null,
+    recoveryAttempts: run.recoveryAttempts ?? null,
+    tags: run.tags ?? null,
+    searchAttributes: run.searchAttributes ?? null,
+    priority: run.priority ?? null,
+    namespace: run.namespace ?? DEFAULT_NAMESPACE,
+    origin: run.origin ?? null,
+    createdAt: run.createdAt,
+    updatedAt: run.updatedAt
+  };
+}
+__name(toRunRow, "toRunRow");
+function toRunPatch(patch) {
+  const row = {};
+  if (patch.workflow !== void 0) row.workflow = patch.workflow;
+  if (patch.workflowVersion !== void 0) row.workflowVersion = patch.workflowVersion;
+  if (patch.status !== void 0) row.status = patch.status;
+  if ("input" in patch) row.input = patch.input ?? null;
+  if ("output" in patch) row.output = patch.output ?? null;
+  if ("error" in patch) row.error = patch.error ?? null;
+  if ("wakeAt" in patch) row.wakeAt = date(patch.wakeAt);
+  if ("lockedBy" in patch) row.lockedBy = patch.lockedBy ?? null;
+  if ("lockedUntil" in patch) row.lockedUntil = date(patch.lockedUntil);
+  if ("awaitingDecisionTaskId" in patch) row.awaitingDecisionTaskId = patch.awaitingDecisionTaskId ?? null;
+  if ("recoveryAttempts" in patch) row.recoveryAttempts = patch.recoveryAttempts ?? null;
+  if ("tags" in patch) row.tags = patch.tags ?? null;
+  if ("searchAttributes" in patch) row.searchAttributes = patch.searchAttributes ?? null;
+  if ("priority" in patch) row.priority = patch.priority ?? null;
+  if ("namespace" in patch) row.namespace = patch.namespace ?? DEFAULT_NAMESPACE;
+  if ("origin" in patch) row.origin = patch.origin ?? null;
+  if (patch.createdAt != null) row.createdAt = patch.createdAt;
+  if (patch.updatedAt != null) row.updatedAt = patch.updatedAt;
+  return row;
+}
+__name(toRunPatch, "toRunPatch");
+function fromRunRow(row) {
+  return {
+    id: row.id,
+    workflow: row.workflow,
+    workflowVersion: row.workflowVersion,
+    status: row.status,
+    input: row.input ?? void 0,
+    output: row.output ?? void 0,
+    error: row.error ?? void 0,
+    wakeAt: ms(row.wakeAt),
+    lockedBy: row.lockedBy ?? void 0,
+    lockedUntil: ms(row.lockedUntil),
+    awaitingDecisionTaskId: row.awaitingDecisionTaskId ?? void 0,
+    recoveryAttempts: row.recoveryAttempts ?? void 0,
+    tags: row.tags ?? void 0,
+    searchAttributes: row.searchAttributes ?? void 0,
+    priority: row.priority ?? void 0,
+    namespace: row.namespace,
+    origin: row.origin ?? void 0,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(fromRunRow, "fromRunRow");
+function toCheckpointRow(cp) {
+  return {
+    runId: cp.runId,
+    seq: cp.seq,
+    name: cp.name,
+    kind: cp.kind,
+    stepId: cp.stepId,
+    status: cp.status,
+    input: cp.input ?? null,
+    output: cp.output ?? null,
+    error: cp.error ?? null,
+    events: cp.events ?? null,
+    attempts: cp.attempts,
+    workerGroup: cp.workerGroup ?? null,
+    parallelGroup: cp.parallelGroup ?? null,
+    wakeAt: date(cp.wakeAt),
+    enqueuedAt: cp.enqueuedAt ?? cp.startedAt,
+    startedAt: cp.startedAt,
+    finishedAt: cp.finishedAt
+  };
+}
+__name(toCheckpointRow, "toCheckpointRow");
+function fromCheckpointRow(row) {
+  return {
+    runId: row.runId,
+    seq: row.seq,
+    name: row.name,
+    kind: row.kind,
+    stepId: row.stepId,
+    status: row.status,
+    input: row.input ?? void 0,
+    output: row.output ?? void 0,
+    error: row.error ?? void 0,
+    events: row.events ?? void 0,
+    attempts: row.attempts,
+    workerGroup: row.workerGroup ?? void 0,
+    parallelGroup: row.parallelGroup ?? void 0,
+    wakeAt: ms(row.wakeAt),
+    // Older rows may lack enqueued_at; treat the start as enqueue time (queue-wait reads zero).
+    enqueuedAt: row.enqueuedAt ?? row.startedAt,
+    startedAt: row.startedAt,
+    finishedAt: row.finishedAt
+  };
+}
+__name(fromCheckpointRow, "fromCheckpointRow");
+
+// src/pg/executor.ts
+import { sql as sql3 } from "drizzle-orm";
+function toDrizzleSql(text2, params = []) {
+  const chunks = [];
+  let last = 0;
+  for (const match of text2.matchAll(/\$(\d+)/g)) {
+    const index2 = Number(match[1]) - 1;
+    if (index2 < 0 || index2 >= params.length) throw new Error(`placeholder ${match[0]} has no bound parameter`);
+    chunks.push(sql3.raw(text2.slice(last, match.index)), sql3`${params[index2]}`);
+    last = (match.index ?? 0) + match[0].length;
+  }
+  chunks.push(sql3.raw(text2.slice(last)));
+  return sql3.join(chunks);
+}
+__name(toDrizzleSql, "toDrizzleSql");
+function rowsOf(result) {
+  if (Array.isArray(result)) return result;
+  return result?.rows ?? [];
+}
+__name(rowsOf, "rowsOf");
+function drizzlePgExecutor(db) {
+  return {
+    dialect: "postgres",
+    escapeId: /* @__PURE__ */ __name((id) => `"${id.replace(/"/g, '""')}"`, "escapeId"),
+    query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await db.execute(toDrizzleSql(text2, params))), "query"),
+    transaction: /* @__PURE__ */ __name((fn) => db.transaction((tx) => fn({
+      query: /* @__PURE__ */ __name(async (text2, params) => rowsOf(await tx.execute(toDrizzleSql(text2, params))), "query")
+    })), "transaction")
+  };
+}
+__name(drizzlePgExecutor, "drizzlePgExecutor");
+export {
+  DEFAULT_NAMESPACE,
+  DURABLE_PG_DDL,
+  DrizzlePgStateStore,
+  drizzlePgExecutor,
+  durableBufferedEvents,
+  durableBufferedSignals,
+  durablePgManagedTables,
+  durablePgSchema,
+  durableRunAttributes,
+  durableSignalWaiters,
+  durableStepCheckpoints,
+  durableWorkflowRuns,
+  ensureDrizzlePgDurableSchema,
+  toDrizzleSql
+};
+//# sourceMappingURL=index.js.map