@dudousxd/nestjs-durable-store-prisma 0.20.0 → 0.22.0

package/dist/index.js

@@ -74,6 +74,22 @@ var PrismaStateStore = class {
     });
     if ("searchAttributes" in patch) await this.reindexAttributes(runId, patch.searchAttributes);
   }
+  async updateRunIf(runId, expectedStatuses, inputPatch) {
+    if (expectedStatuses.length === 0) return false;
+    const patch = inputPatch.status && TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await clearTerminalSingletonAdmission(runId, inputPatch, (id) => this.getRun(id)) : inputPatch;
+    const { count } = await this.db.durableWorkflowRun.updateMany({
+      where: {
+        id: runId,
+        status: {
+          in: expectedStatuses
+        }
+      },
+      data: toRunPatch(patch)
+    });
+    if (count === 0) return false;
+    if ("searchAttributes" in patch) await this.reindexAttributes(runId, patch.searchAttributes);
+    return true;
+  }
   /** 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. */
   async reindexAttributes(runId, attributes) {
@@ -246,6 +262,25 @@ var PrismaStateStore = class {
     });
     return count > 0;
   }
+  async saveCheckpointsIfPending(checkpoints) {
+    if (checkpoints.length === 0) return [];
+    return this.db.$transaction(async (tx) => {
+      const wrote = [];
+      for (const checkpoint of checkpoints) {
+        const { runId, seq, ...data } = toCheckpointData(checkpoint);
+        const { count } = await tx.durableStepCheckpoint.updateMany({
+          where: {
+            runId,
+            seq,
+            status: "pending"
+          },
+          data
+        });
+        wrote.push(count > 0);
+      }
+      return wrote;
+    });
+  }
   async transaction(work) {
     return this.db.$transaction(async (tx) => work({
       raw: tx,
@@ -278,6 +313,35 @@ var PrismaStateStore = class {
     });
     return rows.map(fromRunRow);
   }
+  async listOrphanedRuns(nowMs, limit, namespace) {
+    if (limit <= 0) return [];
+    const rows = await this.db.durableWorkflowRun.findMany({
+      where: {
+        status: {
+          in: [
+            "running",
+            "cancelling"
+          ]
+        },
+        OR: [
+          {
+            lockedUntil: null
+          },
+          {
+            lockedUntil: {
+              lte: new Date(nowMs)
+            }
+          }
+        ],
+        ...namespaceWhere(namespace)
+      },
+      orderBy: {
+        createdAt: "asc"
+      },
+      take: limit
+    });
+    return rows.map(fromRunRow);
+  }
   async listPendingRuns(limit, namespace) {
     const rows = await this.db.durableWorkflowRun.findMany({
       where: {
@@ -610,6 +674,137 @@ var PrismaStateStore = class {
         seq: "asc"
       }
     });
+    return rows.filter((r) => prefixes.some((p) => r.name.startsWith(p))).map(fromCheckpointRow);
+  }
+  /**
+  * One `groupBy(parallelGroup, status)` per {@link CheckpointNameKind}, each narrowed to its kind by
+  * a name-prefix predicate, run concurrently — Prisma cannot group by a `CASE`, so the kind is the
+  * `where` instead. `minEnqueuedAt` reads a NULL `enqueuedAt` as `startedAt` (as
+  * {@link fromCheckpointRow} does): a bucket whose non-null `enqueuedAt` count falls short of its
+  * row count has such rows, and only for those kinds is the NULL subset's `min(startedAt)` asked for.
+  *
+  * On SQLite `startsWith` is a case-insensitive `LIKE`, as in {@link listCheckpointsByNamePrefix};
+  * the kind prefixes are lower-case and wildcard-free, so only a step whose name starts with one of
+  * them in another case would be classified differently there.
+  */
+  async checkpointStats(runId, opts) {
+    const scope = opts?.group === void 0 ? {
+      runId
+    } : {
+      runId,
+      parallelGroup: opts.group
+    };
+    const grouped = await Promise.all(NAME_KINDS.map(async ({ kind, where }) => ({
+      kind,
+      where,
+      rows: await this.db.durableStepCheckpoint.groupBy({
+        by: [
+          "parallelGroup",
+          "status"
+        ],
+        where: {
+          ...scope,
+          ...where
+        },
+        _count: {
+          _all: true,
+          enqueuedAt: true
+        },
+        _min: {
+          seq: true,
+          name: true,
+          enqueuedAt: true,
+          startedAt: true
+        },
+        _max: {
+          seq: true,
+          name: true,
+          startedAt: true,
+          finishedAt: true
+        },
+        _sum: {
+          attempts: true
+        }
+      })
+    })));
+    const stats = await Promise.all(grouped.map(async ({ kind, where, rows }) => {
+      const unenqueued = rows.some((r) => r._count.enqueuedAt < r._count._all) ? await this.unenqueuedStartedAt({
+        ...scope,
+        ...where
+      }) : /* @__PURE__ */ new Map();
+      return rows.map((r) => toCheckpointStat(kind, r, unenqueued));
+    }));
+    return stats.flat();
+  }
+  /** `min(startedAt)` per `(parallelGroup, status)` over the rows whose `enqueuedAt` is NULL. */
+  async unenqueuedStartedAt(where) {
+    const rows = await this.db.durableStepCheckpoint.groupBy({
+      by: [
+        "parallelGroup",
+        "status"
+      ],
+      where: {
+        ...where,
+        enqueuedAt: null
+      },
+      _min: {
+        startedAt: true
+      }
+    });
+    return new Map(rows.map((r) => [
+      bucketKey(r.parallelGroup, r.status),
+      r._min.startedAt
+    ]));
+  }
+  /** {@link CheckpointQuery} as one `findMany`, in `seq` order, paged by `skip`/`take`. Ungrouped rows
+  *  are kept past `excludeGroups` explicitly: `NOT IN` alone drops a NULL `parallelGroup`. */
+  async queryCheckpoints(runId, query) {
+    if (query.statuses?.length === 0 || query.namePrefixes?.length === 0) return [];
+    const and = [];
+    if (query.excludeGroups?.length) {
+      and.push({
+        OR: [
+          {
+            parallelGroup: null
+          },
+          {
+            parallelGroup: {
+              notIn: query.excludeGroups
+            }
+          }
+        ]
+      });
+    }
+    if (query.namePrefixes) {
+      and.push({
+        OR: query.namePrefixes.map((p) => ({
+          name: {
+            startsWith: p
+          }
+        }))
+      });
+    }
+    const rows = await this.db.durableStepCheckpoint.findMany({
+      where: {
+        runId,
+        ...query.group === void 0 ? {} : {
+          parallelGroup: query.group
+        },
+        ...query.statuses ? {
+          status: {
+            in: query.statuses
+          }
+        } : {},
+        ...and.length ? {
+          AND: and
+        } : {}
+      },
+      orderBy: {
+        seq: "asc"
+      },
+      skip: query.offset,
+      take: query.limit
+    });
     return rows.map(fromCheckpointRow);
   }
   async putSignalWaiter(waiter) {
@@ -657,7 +852,7 @@ var PrismaStateStore = class {
         }
       }
     });
-    return rows.map((r) => ({
+    return rows.filter((r) => r.token.startsWith(prefix)).map((r) => ({
       token: r.token,
       runId: r.runId,
       seq: r.seq,
@@ -947,6 +1142,69 @@ function fromRunRow(row) {
   };
 }
 __name(fromRunRow, "fromRunRow");
+var KIND_PREFIXES = [
+  [
+    "child",
+    "signal:child:"
+  ],
+  [
+    "folded",
+    "fan:"
+  ],
+  [
+    "spawn",
+    "spawn:"
+  ]
+];
+var NAME_KINDS = [
+  ...KIND_PREFIXES.map(([kind, prefix]) => ({
+    kind,
+    where: {
+      name: {
+        startsWith: prefix
+      }
+    }
+  })),
+  {
+    kind: "step",
+    where: {
+      NOT: KIND_PREFIXES.map(([, prefix]) => ({
+        name: {
+          startsWith: prefix
+        }
+      }))
+    }
+  }
+];
+function bucketKey(group, status) {
+  return JSON.stringify([
+    group,
+    status
+  ]);
+}
+__name(bucketKey, "bucketKey");
+function toCheckpointStat(nameKind, r, unenqueued) {
+  const fallback = unenqueued.get(bucketKey(r.parallelGroup, r.status));
+  const enqueued = r._min.enqueuedAt;
+  const minEnqueuedAt = enqueued && fallback ? enqueued < fallback ? enqueued : fallback : enqueued ?? fallback;
+  return {
+    group: r.parallelGroup,
+    status: r.status,
+    nameKind,
+    count: r._count._all,
+    minSeq: r._min.seq,
+    maxSeq: r._max.seq,
+    minName: r._min.name,
+    maxName: r._max.name,
+    // Every row has `enqueuedAt` or is in the NULL subset, so one of the two is set.
+    minEnqueuedAt,
+    minStartedAt: r._min.startedAt,
+    maxStartedAt: r._max.startedAt,
+    maxFinishedAt: r._max.finishedAt,
+    sumAttempts: Number(r._sum.attempts ?? 0)
+  };
+}
+__name(toCheckpointStat, "toCheckpointStat");
 function toCheckpointData(cp) {
   return {
     runId: cp.runId,