@dudousxd/nestjs-durable-store-prisma 0.17.0 → 0.18.1

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { StateStore, WorkflowRun, StepCheckpoint, RunQuery, RunFacetQuery, RunFacetRow, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, 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. */
@@ -111,13 +126,16 @@ interface DurablePrismaClient extends DurablePrismaTx {
 declare class PrismaStateStore implements StateStore {
     private readonly db;
     constructor(db: DurablePrismaClient);
+    tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
-    updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
+    updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
     /** Rewrite a run's normalized attribute rows: delete the old set, insert the current one. Mirrors
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     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,6 +151,7 @@ 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. */
@@ -142,6 +161,13 @@ declare class PrismaStateStore implements StateStore {
      *  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, RunValueAxis, RunValueFacetOptions, RunValueFacetRow, 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. */
@@ -111,13 +126,16 @@ interface DurablePrismaClient extends DurablePrismaTx {
 declare class PrismaStateStore implements StateStore {
     private readonly db;
     constructor(db: DurablePrismaClient);
+    tryAdmitSingleton(runId: string, tag: string, workflow: string, limit: number, retryWakeAt?: number): Promise<boolean>;
     createRun(run: WorkflowRun): Promise<void>;
-    updateRun(runId: string, patch: Partial<WorkflowRun>): Promise<void>;
+    updateRun(runId: string, inputPatch: Partial<WorkflowRun>): Promise<void>;
     /** Rewrite a run's normalized attribute rows: delete the old set, insert the current one. Mirrors
      *  the in-memory store's reindex so the side-table always reflects the run's live searchAttributes. */
     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,6 +151,7 @@ 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. */
@@ -142,6 +161,13 @@ declare class PrismaStateStore implements StateStore {
      *  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 { RUN_VALUE_FACET_SCAN, attributePredicateOperands, axisIsRunColumn, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, runValueFacetsFromRuns } from "@dudousxd/nestjs-durable-core";
+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";
 function namespaceWhere(namespace) {
   if (namespace === void 0) return {};
   return {
@@ -18,13 +18,54 @@ var PrismaStateStore = class {
   constructor(db) {
     this.db = db;
   }
+  async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
+    return this.db.$transaction(async (tx) => {
+      const where = {
+        workflow,
+        status: {
+          in: SINGLETON_ACTIVE_STATUSES
+        }
+      };
+      await tx.durableWorkflowRun.updateMany({
+        where,
+        data: {
+          workflow
+        }
+      });
+      const rows = await tx.durableWorkflowRun.findMany({
+        where
+      });
+      const runs = rows.map(fromRunRow);
+      const tags = singletonAdmissionTags(runs, runId, tag, workflow, limit);
+      if (!tags) {
+        const patch = singletonAdmissionDenialPatch(runs, runId, tag, workflow, retryWakeAt);
+        if (patch) await tx.durableWorkflowRun.update({
+          where: {
+            id: runId
+          },
+          data: toRunPatch(patch)
+        });
+        return false;
+      }
+      await tx.durableWorkflowRun.update({
+        where: {
+          id: runId
+        },
+        data: {
+          tags
+        }
+      });
+      return true;
+    });
+  }
   async createRun(run) {
     await this.db.durableWorkflowRun.create({
       data: toRunData(run)
     });
     await this.reindexAttributes(run.id, run.searchAttributes);
   }
-  async updateRun(runId, patch) {
+  async updateRun(runId, inputPatch) {
+    const patch = inputPatch.status && TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await clearTerminalSingletonAdmission(runId, inputPatch, (id) => this.getRun(id)) : inputPatch;
     await this.db.durableWorkflowRun.update({
       where: {
         id: runId
@@ -76,6 +117,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: {
@@ -259,6 +393,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. */
@@ -305,6 +444,101 @@ var PrismaStateStore = class {
       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: {
@@ -626,6 +860,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() {
@@ -635,7 +902,8 @@ function durableManagedTables() {
     "durable_run_attributes",
     "durable_signal_waiters",
     "durable_buffered_signals",
-    "durable_buffered_events"
+    "durable_buffered_events",
+    "durable_schedules"
   ];
 }
 __name(durableManagedTables, "durableManagedTables");