@dudousxd/nestjs-durable-store-drizzle 0.19.1 → 0.21.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, CheckpointStat, CheckpointQuery, SignalWaiter, ChildWait } from '@dudousxd/nestjs-durable-core';
 import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 
@@ -23,6 +23,8 @@ declare class DrizzleStateStore implements StateStore {
     pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
+    saveCheckpointIfPending(checkpoint: StepCheckpoint): Promise<boolean>;
+    saveCheckpointsIfPending(checkpoints: StepCheckpoint[]): Promise<boolean[]>;
     transaction<T>(work: (tx: {
         raw: unknown;
         saveCheckpoint: (cp: StepCheckpoint) => Promise<void>;
@@ -64,7 +66,16 @@ declare class DrizzleStateStore implements StateStore {
     listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
     listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
+    countCheckpoints(runId: string, fromSeq: number, toSeq: number, statuses: StepCheckpoint['status'][]): Promise<number>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;
+    /** {@link StateStore.checkpointStats}: one `GROUP BY parallel_group, status, name_kind` over the
+     *  run's checkpoints, so a wide fan comes back as a few bucket rows instead of every member. */
+    checkpointStats(runId: string, opts?: {
+        group?: string | undefined;
+    }): Promise<CheckpointStat[]>;
+    /** {@link StateStore.queryCheckpoints}: the run's checkpoints narrowed in SQL, in `seq` order and
+     *  paged there, so reading one page of a wide fan never loads the rest of it. */
+    queryCheckpoints(runId: string, query: CheckpointQuery): Promise<StepCheckpoint[]>;
     putSignalWaiter(waiter: SignalWaiter): Promise<void>;
     takeSignalWaiter(token: string): Promise<SignalWaiter | null>;
     listSignalWaiters(prefix: string): Promise<SignalWaiter[]>;

package/dist/index.js

@@ -3,7 +3,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/drizzle-state-store.ts
 import { RUN_VALUE_FACET_SCAN, SINGLETON_ACTIVE_STATUSES, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, clearTerminalSingletonAdmission, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns, singletonAdmissionDenialPatch, singletonAdmissionTags } from "@dudousxd/nestjs-durable-core";
-import { and, asc, desc, eq, exists, getTableColumns, gte, inArray, isNotNull, isNull, like, lt, lte, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, exists, getTableColumns, gte, inArray, isNotNull, isNull, like, lt, lte, notInArray, or, sql } from "drizzle-orm";
 
 // src/schema.ts
 import { getTableName } from "drizzle-orm";
@@ -119,7 +119,13 @@ var stepCheckpoints = sqliteTable("durable_step_checkpoints", {
       t.runId,
       t.seq
     ]
-  })
+  }),
+  // A run detail reads one fan at a time (`checkpointStats({ group })`, `queryCheckpoints({ group })`
+  // paged by seq). Like every index here, an already-deployed database needs it run by hand:
+  //
+  //     CREATE INDEX IF NOT EXISTS durable_step_checkpoints_group_idx
+  //       ON durable_step_checkpoints (run_id, parallel_group, seq);
+  index("durable_step_checkpoints_group_idx").on(t.runId, t.parallelGroup, t.seq)
 ]);
 var runAttributes = sqliteTable("durable_run_attributes", {
   runId: text("run_id").notNull(),
@@ -335,6 +341,41 @@ var DrizzleStateStore = class {
       set: row
     });
   }
+  async saveCheckpointIfPending(checkpoint) {
+    const { runId, seq, ...set } = toCheckpointRow(checkpoint);
+    const result = await this.db.update(stepCheckpoints).set(set).where(and(eq(stepCheckpoints.runId, runId), eq(stepCheckpoints.seq, seq), eq(stepCheckpoints.status, "pending")));
+    const { changes, rowsAffected } = result;
+    return (changes ?? rowsAffected ?? 0) > 0;
+  }
+  async saveCheckpointsIfPending(checkpoints) {
+    if (checkpoints.length === 0) return [];
+    const wrote = [];
+    await this.db.transaction((tx) => {
+      const update = /* @__PURE__ */ __name((checkpoint) => {
+        const { runId, seq, ...set } = toCheckpointRow(checkpoint);
+        return tx.update(stepCheckpoints).set(set).where(and(eq(stepCheckpoints.runId, runId), eq(stepCheckpoints.seq, seq), eq(stepCheckpoints.status, "pending"))).run();
+      }, "update");
+      const record = /* @__PURE__ */ __name((result) => {
+        const { changes, rowsAffected } = result;
+        wrote.push((changes ?? rowsAffected ?? 0) > 0);
+      }, "record");
+      const runFrom = /* @__PURE__ */ __name((from) => {
+        for (let i = from; i < checkpoints.length; i += 1) {
+          const result = update(checkpoints[i]);
+          if (result instanceof Promise) {
+            return result.then((r) => {
+              record(r);
+              return runFrom(i + 1);
+            });
+          }
+          record(result);
+        }
+        return void 0;
+      }, "runFrom");
+      return runFrom(0);
+    });
+    return wrote;
+  }
   async transaction(work) {
     return this.db.transaction(async (tx) => work({
       raw: tx,
@@ -527,9 +568,71 @@ var DrizzleStateStore = class {
     const rows = await this.db.select().from(stepCheckpoints).where(and(eq(stepCheckpoints.runId, runId), eq(stepCheckpoints.name, name))).orderBy(desc(stepCheckpoints.seq)).limit(1);
     return rows[0] ? fromCheckpointRow(rows[0]) : void 0;
   }
+  async countCheckpoints(runId, fromSeq, toSeq, statuses) {
+    if (statuses.length === 0) return 0;
+    const rows = await this.db.select({
+      count: sql`count(*)`
+    }).from(stepCheckpoints).where(and(eq(stepCheckpoints.runId, runId), gte(stepCheckpoints.seq, fromSeq), lte(stepCheckpoints.seq, toSeq), inArray(stepCheckpoints.status, statuses)));
+    return Number(rows[0]?.count ?? 0);
+  }
   async listCheckpointsByNamePrefix(runId, prefixes) {
     if (prefixes.length === 0) return [];
     const rows = await this.db.select().from(stepCheckpoints).where(and(eq(stepCheckpoints.runId, runId), or(...prefixes.map((p) => like(stepCheckpoints.name, `${p}%`))))).orderBy(asc(stepCheckpoints.seq));
+    return rows.filter((r) => prefixes.some((p) => r.name.startsWith(p))).map(fromCheckpointRow);
+  }
+  /** {@link StateStore.checkpointStats}: one `GROUP BY parallel_group, status, name_kind` over the
+  *  run's checkpoints, so a wide fan comes back as a few bucket rows instead of every member. */
+  async checkpointStats(runId, opts) {
+    const c = stepCheckpoints;
+    const nameKind = sql`CASE
+      WHEN substr(${c.name}, 1, 13) = 'signal:child:' THEN 'child'
+      WHEN substr(${c.name}, 1, 4) = 'fan:' THEN 'folded'
+      WHEN substr(${c.name}, 1, 6) = 'spawn:' THEN 'spawn'
+      ELSE 'step' END`.as("name_kind");
+    const rows = await this.db.select({
+      group: c.parallelGroup,
+      status: c.status,
+      nameKind,
+      count: sql`count(*)`,
+      minSeq: sql`min(${c.seq})`,
+      maxSeq: sql`max(${c.seq})`,
+      minName: sql`min(${c.name})`,
+      maxName: sql`max(${c.name})`,
+      minEnqueuedAt: sql`min(coalesce(${c.enqueuedAt}, ${c.startedAt}))`,
+      minStartedAt: sql`min(${c.startedAt})`,
+      maxStartedAt: sql`max(${c.startedAt})`,
+      maxFinishedAt: sql`max(${c.finishedAt})`,
+      sumAttempts: sql`sum(${c.attempts})`
+    }).from(c).where(and(eq(c.runId, runId), opts?.group !== void 0 ? eq(c.parallelGroup, opts.group) : void 0)).groupBy(c.parallelGroup, c.status, sql`name_kind`);
+    return rows.map((r) => ({
+      group: r.group ?? null,
+      status: r.status,
+      nameKind: r.nameKind,
+      count: Number(r.count),
+      minSeq: Number(r.minSeq),
+      maxSeq: Number(r.maxSeq),
+      minName: r.minName,
+      maxName: r.maxName,
+      minEnqueuedAt: new Date(Number(r.minEnqueuedAt)),
+      minStartedAt: new Date(Number(r.minStartedAt)),
+      maxStartedAt: new Date(Number(r.maxStartedAt)),
+      maxFinishedAt: new Date(Number(r.maxFinishedAt)),
+      sumAttempts: Number(r.sumAttempts)
+    }));
+  }
+  /** {@link StateStore.queryCheckpoints}: the run's checkpoints narrowed in SQL, in `seq` order and
+  *  paged there, so reading one page of a wide fan never loads the rest of it. */
+  async queryCheckpoints(runId, query) {
+    if (query.statuses?.length === 0 || query.namePrefixes?.length === 0) return [];
+    const c = stepCheckpoints;
+    const rows = await this.db.select().from(c).where(and(
+      eq(c.runId, runId),
+      query.group !== void 0 ? eq(c.parallelGroup, query.group) : void 0,
+      // `NOT IN` is never true for a NULL group, so ungrouped rows are kept explicitly.
+      query.excludeGroups?.length ? or(isNull(c.parallelGroup), notInArray(c.parallelGroup, query.excludeGroups)) : void 0,
+      query.statuses ? inArray(c.status, query.statuses) : void 0,
+      query.namePrefixes ? or(...query.namePrefixes.map((p) => sql`substr(${c.name}, 1, length(${p})) = ${p}`)) : void 0
+    )).orderBy(asc(c.seq)).limit(query.limit ?? Number.MAX_SAFE_INTEGER).offset(query.offset ?? 0);
     return rows.map(fromCheckpointRow);
   }
   async putSignalWaiter(waiter) {
@@ -561,7 +664,7 @@ var DrizzleStateStore = class {
   }
   async listSignalWaiters(prefix) {
     const rows = await this.db.select().from(signalWaiters).where(like(signalWaiters.token, `${prefix}%`));
-    return rows.map((r) => ({
+    return rows.filter((r) => r.token.startsWith(prefix)).map((r) => ({
       token: r.token,
       runId: r.runId,
       seq: r.seq,