@dudousxd/nestjs-durable-store-prisma 0.16.0 → 0.18.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { StateStore, WorkflowRun, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 interface RunRow {
     id: string;
@@ -82,10 +82,23 @@ interface Delegate<Row> {
     deleteMany(args?: Args): Promise<{
         count: number;
     }>;
+    count(args?: Args): Promise<number>;
     /** Aggregate form — used only by `runFacets`, whose rows are `(status, origin, count)` cells, not
      *  model rows, so the result type is stated at the call site rather than derived from `Row`. */
     groupBy(args: Args): Promise<Record<string, unknown>[]>;
 }
+interface ScheduleRow {
+    id: string;
+    namespace: string;
+    workflow: string;
+    paused: boolean;
+    nextFireAt: bigint | null;
+    tags: unknown;
+    spec: unknown;
+    state: unknown;
+    createdAt: Date;
+    updatedAt: Date;
+}
 interface DurablePrismaTx {
     durableWorkflowRun: Delegate<RunRow>;
     durableStepCheckpoint: Delegate<CheckpointRow>;
@@ -93,6 +106,8 @@ interface DurablePrismaTx {
     durableSignalWaiter: Delegate<WaiterRow>;
     durableBufferedSignal: Delegate<BufferedSignalRow>;
     durableBufferedEvent: Delegate<BufferedEventRow>;
+    /** Only needed for persisted schedules (`engine.schedules`) — add the `DurableSchedule` model. */
+    durableSchedule?: Delegate<ScheduleRow>;
 }
 interface DurablePrismaClient extends DurablePrismaTx {
     /** Prisma's interactive-transaction form: runs `fn` with a tx-scoped client and commits on resolve. */
@@ -118,6 +133,8 @@ declare class PrismaStateStore implements StateStore {
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
+    deleteRuns(runIds: string[]): Promise<void>;
+    pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     transaction<T>(work: (tx: {
@@ -133,10 +150,23 @@ declare class PrismaStateStore implements StateStore {
     /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it. */
     private runWhere;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    countRuns(query: Omit<RunQuery, 'limit' | 'offset'>): Promise<number>;
     /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
      *  console can show whole-set counts next to a bounded page instead of downloading every run to
      *  count them in the browser. */
     runFacets(query: RunFacetQuery): Promise<RunFacetRow[]>;
+    /** Distinct values of one filter axis over the same predicates {@link listRuns} pages. A run-table
+     *  column is a `groupBy` like {@link runFacets}, exact over the whole matching set; the tag and
+     *  attribute axes live outside the row (json column / side table) and are counted from a bounded
+     *  page of runs instead — see `RunValueFacetOptions.scan`. */
+    runValueFacets(axis: RunValueAxis, query: RunFacetQuery, opts?: RunValueFacetOptions): Promise<RunValueFacetRow[]>;
+    private schedules;
+    saveSchedule(record: ScheduleRecord): Promise<void>;
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    /** One conditional `updateMany`: the compare-and-set on `next_fire_at` is a single statement. */
+    updateSchedule(id: string, patch: Partial<Omit<ScheduleRecord, 'id' | 'createdAt'>>, expectedNextFireAt?: number | null): Promise<boolean>;
+    deleteSchedule(id: string): Promise<boolean>;
+    listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
     listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { StateStore, WorkflowRun, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, SignalWaiter } from '@dudousxd/nestjs-durable-core';
+import { StateStore, WorkflowRun, RetentionPolicy, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, ScheduleRecord, ScheduleQuery, SignalWaiter } from '@dudousxd/nestjs-durable-core';
 
 interface RunRow {
     id: string;
@@ -82,10 +82,23 @@ interface Delegate<Row> {
     deleteMany(args?: Args): Promise<{
         count: number;
     }>;
+    count(args?: Args): Promise<number>;
     /** Aggregate form — used only by `runFacets`, whose rows are `(status, origin, count)` cells, not
      *  model rows, so the result type is stated at the call site rather than derived from `Row`. */
     groupBy(args: Args): Promise<Record<string, unknown>[]>;
 }
+interface ScheduleRow {
+    id: string;
+    namespace: string;
+    workflow: string;
+    paused: boolean;
+    nextFireAt: bigint | null;
+    tags: unknown;
+    spec: unknown;
+    state: unknown;
+    createdAt: Date;
+    updatedAt: Date;
+}
 interface DurablePrismaTx {
     durableWorkflowRun: Delegate<RunRow>;
     durableStepCheckpoint: Delegate<CheckpointRow>;
@@ -93,6 +106,8 @@ interface DurablePrismaTx {
     durableSignalWaiter: Delegate<WaiterRow>;
     durableBufferedSignal: Delegate<BufferedSignalRow>;
     durableBufferedEvent: Delegate<BufferedEventRow>;
+    /** Only needed for persisted schedules (`engine.schedules`) — add the `DurableSchedule` model. */
+    durableSchedule?: Delegate<ScheduleRow>;
 }
 interface DurablePrismaClient extends DurablePrismaTx {
     /** Prisma's interactive-transaction form: runs `fn` with a tx-scoped client and commits on resolve. */
@@ -118,6 +133,8 @@ declare class PrismaStateStore implements StateStore {
     private reindexAttributes;
     getRun(runId: string): Promise<WorkflowRun | null>;
     deleteRun(runId: string): Promise<void>;
+    deleteRuns(runIds: string[]): Promise<void>;
+    pruneTerminalRuns(policy: RetentionPolicy, nowMs: number, limit: number): Promise<number>;
     getCheckpoint(runId: string, seq: number): Promise<StepCheckpoint | null>;
     saveCheckpoint(checkpoint: StepCheckpoint): Promise<void>;
     transaction<T>(work: (tx: {
@@ -133,10 +150,23 @@ declare class PrismaStateStore implements StateStore {
     /** The `where` every run query shares — {@link listRuns} pages it, {@link runFacets} groups it. */
     private runWhere;
     listRuns(query: RunQuery): Promise<WorkflowRun[]>;
+    countRuns(query: Omit<RunQuery, 'limit' | 'offset'>): Promise<number>;
     /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
      *  console can show whole-set counts next to a bounded page instead of downloading every run to
      *  count them in the browser. */
     runFacets(query: RunFacetQuery): Promise<RunFacetRow[]>;
+    /** Distinct values of one filter axis over the same predicates {@link listRuns} pages. A run-table
+     *  column is a `groupBy` like {@link runFacets}, exact over the whole matching set; the tag and
+     *  attribute axes live outside the row (json column / side table) and are counted from a bounded
+     *  page of runs instead — see `RunValueFacetOptions.scan`. */
+    runValueFacets(axis: RunValueAxis, query: RunFacetQuery, opts?: RunValueFacetOptions): Promise<RunValueFacetRow[]>;
+    private schedules;
+    saveSchedule(record: ScheduleRecord): Promise<void>;
+    getSchedule(id: string): Promise<ScheduleRecord | null>;
+    /** One conditional `updateMany`: the compare-and-set on `next_fire_at` is a single statement. */
+    updateSchedule(id: string, patch: Partial<Omit<ScheduleRecord, 'id' | 'createdAt'>>, expectedNextFireAt?: number | null): Promise<boolean>;
+    deleteSchedule(id: string): Promise<boolean>;
+    listSchedules(query: ScheduleQuery): Promise<ScheduleRecord[]>;
     listCheckpoints(runId: string): Promise<StepCheckpoint[]>;
     getLatestCheckpointByName(runId: string, name: string): Promise<StepCheckpoint | undefined>;
     listCheckpointsByNamePrefix(runId: string, prefixes: string[]): Promise<StepCheckpoint[]>;

package/dist/index.js

@@ -2,7 +2,7 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/prisma-state-store.ts
-import { attributeColumnFor, attributeOperand, mergeRunFacetRows, normalizeAttributeRows } from "@dudousxd/nestjs-durable-core";
+import { RUN_VALUE_FACET_SCAN, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, runValueFacetsFromRuns } from "@dudousxd/nestjs-durable-core";
 function namespaceWhere(namespace) {
   if (namespace === void 0) return {};
   return {
@@ -76,6 +76,99 @@ var PrismaStateStore = class {
       }
     });
   }
+  async deleteRuns(runIds) {
+    if (runIds.length === 0) return;
+    await this.db.$transaction(async (tx) => {
+      await tx.durableStepCheckpoint.deleteMany({
+        where: {
+          runId: {
+            in: runIds
+          }
+        }
+      });
+      await tx.durableSignalWaiter.deleteMany({
+        where: {
+          runId: {
+            in: runIds
+          }
+        }
+      });
+      await tx.durableRunAttribute.deleteMany({
+        where: {
+          runId: {
+            in: runIds
+          }
+        }
+      });
+      await tx.durableWorkflowRun.deleteMany({
+        where: {
+          id: {
+            in: runIds
+          }
+        }
+      });
+    });
+  }
+  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;
+    const scoped = this.runWhere({
+      ...policy.scope ?? {},
+      statuses
+    });
+    const ids = /* @__PURE__ */ new Set();
+    if (policy.maxAge != null) {
+      const cutoff = new Date(nowMs - parseDuration(policy.maxAge));
+      const rows = await this.db.durableWorkflowRun.findMany({
+        where: {
+          AND: [
+            scoped,
+            {
+              updatedAt: {
+                lt: cutoff
+              }
+            }
+          ]
+        },
+        select: {
+          id: true
+        },
+        orderBy: {
+          updatedAt: "asc"
+        },
+        take: limit
+      });
+      for (const r of rows) ids.add(r.id);
+    }
+    if (policy.maxCount != null && ids.size < limit) {
+      const rows = await this.db.durableWorkflowRun.findMany({
+        where: scoped,
+        select: {
+          id: true
+        },
+        orderBy: [
+          {
+            updatedAt: "desc"
+          },
+          {
+            id: "desc"
+          }
+        ],
+        skip: policy.maxCount,
+        take: limit
+      });
+      for (const r of rows) {
+        if (ids.size >= limit) break;
+        ids.add(r.id);
+      }
+    }
+    const doomed = [
+      ...ids
+    ].slice(0, limit);
+    await this.deleteRuns(doomed);
+    return doomed.length;
+  }
   async getCheckpoint(runId, seq) {
     const row = await this.db.durableStepCheckpoint.findUnique({
       where: {
@@ -208,19 +301,26 @@ var PrismaStateStore = class {
     const where = {
       ...namespaceWhere(query.namespace)
     };
+    const and = [];
     if (query.workflow) where.workflow = query.workflow;
+    if (query.workflows) and.push(anyOf(query.workflows.map((w) => ({
+      workflow: w
+    }))));
+    if (query.namespaces) and.push(anyOf(query.namespaces.map((n) => ({
+      namespace: n
+    }))));
     if (query.origin !== void 0) where.origin = query.origin;
+    if (query.origins) and.push(anyOf(query.origins.map((o) => ({
+      origin: o
+    }))));
     if (query.status && query.statuses) {
-      where.AND = [
-        {
-          status: query.status
-        },
-        {
-          status: {
-            in: query.statuses
-          }
+      and.push({
+        status: query.status
+      }, {
+        status: {
+          in: query.statuses
         }
-      ];
+      });
     } else if (query.status) {
       where.status = query.status;
     } else if (query.statuses) {
@@ -231,13 +331,13 @@ var PrismaStateStore = class {
     if (query.tag) where.tags = {
       array_contains: query.tag
     };
-    if (query.attributes?.length) {
-      const existing = where.AND ?? [];
-      where.AND = [
-        ...existing,
-        ...query.attributes.map((f) => attributeSome(f))
-      ];
-    }
+    if (query.tags) and.push(anyOf(query.tags.map((t) => ({
+      tags: {
+        array_contains: t
+      }
+    }))));
+    if (query.attributes?.length) and.push(...query.attributes.map((f) => attributeSome(f)));
+    if (and.length) where.AND = and;
     return where;
   }
   async listRuns(query) {
@@ -252,6 +352,11 @@ var PrismaStateStore = class {
     });
     return rows.map(fromRunRow);
   }
+  async countRuns(query) {
+    return this.db.durableWorkflowRun.count({
+      where: this.runWhere(query)
+    });
+  }
   /** `GROUP BY status, origin` over the same predicates {@link listRuns} pages — one aggregate, so a
   *  console can show whole-set counts next to a bounded page instead of downloading every run to
   *  count them in the browser. */
@@ -272,6 +377,127 @@ var PrismaStateStore = class {
       count: r._count._all
     })));
   }
+  /** Distinct values of one filter axis over the same predicates {@link listRuns} pages. A run-table
+  *  column is a `groupBy` like {@link runFacets}, exact over the whole matching set; the tag and
+  *  attribute axes live outside the row (json column / side table) and are counted from a bounded
+  *  page of runs instead — see `RunValueFacetOptions.scan`. */
+  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 rows = await this.db.durableWorkflowRun.groupBy({
+      by: [
+        axis.field
+      ],
+      where: this.runWhere(query),
+      _count: {
+        _all: true
+      }
+    });
+    return mergeRunValueFacetRows(rows.map((r) => ({
+      value: r[axis.field] ?? null,
+      count: r._count._all
+    })), opts);
+  }
+  // ---- persisted schedules ----------------------------------------------------------------------
+  schedules() {
+    const delegate = this.db.durableSchedule;
+    if (!delegate) {
+      throw new Error("persisted schedules need the DurableSchedule model \u2014 copy it from prisma/schema.prisma into your schema and re-run `prisma generate`");
+    }
+    return delegate;
+  }
+  async saveSchedule(record) {
+    const data = toScheduleData(record);
+    await this.schedules().upsert({
+      where: {
+        id: record.id
+      },
+      create: data,
+      update: data
+    });
+  }
+  async getSchedule(id) {
+    const row = await this.schedules().findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? fromScheduleRow(row) : null;
+  }
+  /** One conditional `updateMany`: the compare-and-set on `next_fire_at` is a single statement. */
+  async updateSchedule(id, patch, expectedNextFireAt) {
+    const data = {};
+    if (patch.namespace !== void 0) data.namespace = patch.namespace;
+    if (patch.workflow !== void 0) data.workflow = patch.workflow;
+    if (patch.paused !== void 0) data.paused = patch.paused;
+    if ("nextFireAt" in patch) data.nextFireAt = patch.nextFireAt == null ? null : BigInt(patch.nextFireAt);
+    if ("tags" in patch) data.tags = jsonOrNull(patch.tags);
+    if (patch.spec !== void 0) data.spec = patch.spec;
+    if (patch.state !== void 0) data.state = patch.state;
+    if (patch.updatedAt !== void 0) data.updatedAt = patch.updatedAt;
+    if (!Object.keys(data).length) return await this.getSchedule(id) !== null;
+    const where = {
+      id
+    };
+    if (expectedNextFireAt !== void 0) where.nextFireAt = expectedNextFireAt === null ? null : BigInt(expectedNextFireAt);
+    const { count } = await this.schedules().updateMany({
+      where,
+      data
+    });
+    return count > 0;
+  }
+  async deleteSchedule(id) {
+    const { count } = await this.schedules().deleteMany({
+      where: {
+        id
+      }
+    });
+    return count > 0;
+  }
+  async listSchedules(query) {
+    const where = {};
+    if (query.namespace !== void 0) where.namespace = query.namespace;
+    if (query.workflow !== void 0) where.workflow = query.workflow;
+    if (query.paused !== void 0) where.paused = query.paused;
+    if (query.tag !== void 0) where.tags = {
+      array_contains: query.tag
+    };
+    if (query.dueBy !== void 0) {
+      where.AND = [
+        {
+          paused: false
+        },
+        {
+          nextFireAt: {
+            lte: BigInt(query.dueBy)
+          }
+        }
+      ];
+    }
+    const rows = await this.schedules().findMany({
+      where,
+      // Soonest-due first, never-firing (NULL) last, id as the stable tie-break.
+      orderBy: [
+        {
+          nextFireAt: {
+            sort: "asc",
+            nulls: "last"
+          }
+        },
+        {
+          id: "asc"
+        }
+      ],
+      take: query.limit,
+      skip: query.offset
+    });
+    return rows.map(fromScheduleRow);
+  }
   async listCheckpoints(runId) {
     const rows = await this.db.durableStepCheckpoint.findMany({
       where: {
@@ -436,23 +662,35 @@ var PrismaStateStore = class {
   }
 };
 function attributeSome(f) {
-  const col = attributeColumnFor(f);
-  const operand = attributeOperand(f);
-  const condition = f.op === "eq" ? operand : f.op === "ne" ? {
-    not: operand
-  } : {
-    [f.op]: operand
-  };
+  const comparisons = attributePredicateOperands(f).map(({ column, comparator, operand }) => ({
+    [column]: comparator === "=" ? operand : comparator === "<>" ? {
+      not: operand
+    } : {
+      [f.op]: operand
+    }
+  }));
+  if (comparisons.length === 0) return MATCHES_NOTHING;
   return {
     attributes: {
       some: {
         key: f.key,
-        [col]: condition
+        ...anyOf(comparisons)
       }
     }
   };
 }
 __name(attributeSome, "attributeSome");
+var MATCHES_NOTHING = {
+  id: {
+    in: []
+  }
+};
+function anyOf(branches) {
+  return branches.length ? {
+    OR: branches
+  } : MATCHES_NOTHING;
+}
+__name(anyOf, "anyOf");
 var bigOrNull = /* @__PURE__ */ __name((n) => n == null ? null : BigInt(n), "bigOrNull");
 var numOrUndef = /* @__PURE__ */ __name((n) => n == null ? void 0 : Number(n), "numOrUndef");
 var jsonOrNull = /* @__PURE__ */ __name((v) => v ?? null, "jsonOrNull");
@@ -581,6 +819,39 @@ function fromCheckpointRow(row) {
   };
 }
 __name(fromCheckpointRow, "fromCheckpointRow");
+function toScheduleData(r) {
+  return {
+    id: r.id,
+    namespace: r.namespace,
+    workflow: r.workflow,
+    paused: r.paused,
+    nextFireAt: r.nextFireAt == null ? null : BigInt(r.nextFireAt),
+    tags: jsonOrNull(r.tags),
+    spec: r.spec,
+    state: r.state,
+    createdAt: r.createdAt,
+    updatedAt: r.updatedAt
+  };
+}
+__name(toScheduleData, "toScheduleData");
+function fromScheduleRow(row) {
+  const tags = Array.isArray(row.tags) ? row.tags : void 0;
+  return {
+    id: row.id,
+    namespace: row.namespace,
+    workflow: row.workflow,
+    paused: row.paused,
+    nextFireAt: row.nextFireAt == null ? null : Number(row.nextFireAt),
+    ...tags?.length ? {
+      tags
+    } : {},
+    spec: row.spec ?? {},
+    state: row.state ?? {},
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(fromScheduleRow, "fromScheduleRow");
 
 // src/schema.ts
 function durableManagedTables() {
@@ -590,7 +861,8 @@ function durableManagedTables() {
     "durable_run_attributes",
     "durable_signal_waiters",
     "durable_buffered_signals",
-    "durable_buffered_events"
+    "durable_buffered_events",
+    "durable_schedules"
   ];
 }
 __name(durableManagedTables, "durableManagedTables");