@dudousxd/nestjs-durable-store-typeorm 0.20.1 → 0.22.0

package/dist/index.cjs

@@ -298,6 +298,18 @@ function durableEntities(options = {}) {
     name: "StepCheckpointEntity",
     target: StepCheckpointEntity,
     tableName: "durable_step_checkpoints",
+    // A run's fan, in member order: `checkpointStats`/`queryCheckpoints` narrow by group and page by
+    // seq. The DDL that actually creates it lives in `ensureTypeOrmDurableSchema`.
+    indices: [
+      {
+        name: "durable_step_checkpoints_group_idx",
+        columns: [
+          "runId",
+          "parallelGroup",
+          "seq"
+        ]
+      }
+    ],
     columns: {
       runId: {
         type: "text",
@@ -840,6 +852,13 @@ async function ensureTypeOrmDurableSchema(dataSource) {
         "durable_runs_namespace_status_idx",
         `${runs} (${runsCol("namespace")}, ${runsCol("status")}, ${runsCol("createdAt")})`
       ],
+      // A run's checkpoints by fan, in seq order: the run detail's per-group aggregates and fan
+      // pages. `parallel_group` is `varchar(191)` in this DDL (also when added by ALTER above), so
+      // MySQL can key it without a prefix length.
+      [
+        "durable_step_checkpoints_group_idx",
+        `${checkpoints} (${cpCol("runId")}, ${cpCol("parallelGroup")}, ${cpCol("seq")})`
+      ],
       // A run's waiters: the `ctx.all` join barrier probes them once per settled child.
       [
         "durable_signal_waiters_run_id_idx",
@@ -899,6 +918,7 @@ __name(existingColumns, "existingColumns");
 // src/typeorm-state-store.ts
 var import_nestjs_durable_core = require("@dudousxd/nestjs-durable-core");
 var import_typeorm2 = require("typeorm");
+var CHECKPOINT_NAME_KIND_SQL = "CASE WHEN cp.name LIKE 'signal:child:%' THEN 'child' WHEN cp.name LIKE 'fan:%' THEN 'folded' WHEN cp.name LIKE 'spawn:%' THEN 'spawn' ELSE 'step' END";
 var sqliteSingletonClaims = /* @__PURE__ */ new WeakMap();
 var TypeOrmStateStore = class {
   static {
@@ -1104,6 +1124,18 @@ var TypeOrmStateStore = class {
       "seq"
     ]);
   }
+  async saveCheckpointIfPending(checkpoint) {
+    return updateIfPending(this.checkpoints(), checkpoint);
+  }
+  async saveCheckpointsIfPending(checkpoints) {
+    if (checkpoints.length === 0) return [];
+    return this.dataSource.transaction(async (em) => {
+      const repo = em.getRepository(StepCheckpointEntity);
+      const wrote = [];
+      for (const checkpoint of checkpoints) wrote.push(await updateIfPending(repo, checkpoint));
+      return wrote;
+    });
+  }
   async transaction(work) {
     return this.dataSource.transaction(async (em) => work({
       raw: em,
@@ -1404,6 +1436,15 @@ var TypeOrmStateStore = class {
     });
     return e ? fromCheckpointEntity(e) : void 0;
   }
+  async countCheckpoints(runId, fromSeq, toSeq, statuses) {
+    if (statuses.length === 0) return 0;
+    const row = await this.checkpoints().createQueryBuilder("cp").select("COUNT(*)", "count").where({
+      runId,
+      seq: (0, import_typeorm2.Between)(fromSeq, toSeq),
+      status: (0, import_typeorm2.In)(statuses)
+    }).getRawOne();
+    return Number(row?.count ?? 0);
+  }
   async listCheckpointsByNamePrefix(runId, prefixes) {
     if (prefixes.length === 0) return [];
     const rows = await this.checkpoints().find({
@@ -1415,7 +1456,71 @@ var TypeOrmStateStore = class {
         seq: "ASC"
       }
     });
-    return rows.map(fromCheckpointEntity);
+    return rows.filter((r) => prefixes.some((p) => r.name.startsWith(p))).map(fromCheckpointEntity);
+  }
+  /** `GROUP BY parallelGroup, status, nameKind` over one run's checkpoints — one aggregate, so a run
+  *  detail draws a wide fan from a few bucket rows instead of loading every member. The `CASE` is
+  *  {@link checkpointNameKind} in SQL, and the date aggregates are hydrated through the driver the
+  *  way an entity read hydrates the column, so a bucket compares equal to the in-memory reference. */
+  async checkpointStats(runId, opts) {
+    const qb = this.checkpoints().createQueryBuilder("cp").select("cp.parallelGroup", "group").addSelect("cp.status", "status").addSelect(CHECKPOINT_NAME_KIND_SQL, "nameKind").addSelect("COUNT(*)", "count").addSelect("MIN(cp.seq)", "minSeq").addSelect("MAX(cp.seq)", "maxSeq").addSelect("MIN(cp.name)", "minName").addSelect("MAX(cp.name)", "maxName").addSelect("MIN(COALESCE(cp.enqueuedAt, cp.startedAt))", "minEnqueuedAt").addSelect("MIN(cp.startedAt)", "minStartedAt").addSelect("MAX(cp.startedAt)", "maxStartedAt").addSelect("MAX(cp.finishedAt)", "maxFinishedAt").addSelect("SUM(cp.attempts)", "sumAttempts").where("cp.runId = :runId", {
+      runId
+    });
+    if (opts?.group !== void 0) qb.andWhere("cp.parallelGroup = :group", {
+      group: opts.group
+    });
+    const rows = await qb.groupBy("cp.parallelGroup").addGroupBy("cp.status").addGroupBy(CHECKPOINT_NAME_KIND_SQL).getRawMany();
+    const dateColumn = this.dataSource.getMetadata(StepCheckpointEntity).findColumnWithPropertyName("startedAt");
+    const toDate = /* @__PURE__ */ __name((raw) => dateColumn ? this.dataSource.driver.prepareHydratedValue(raw, dateColumn) : new Date(raw), "toDate");
+    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: toDate(r.minEnqueuedAt),
+      minStartedAt: toDate(r.minStartedAt),
+      maxStartedAt: toDate(r.maxStartedAt),
+      maxFinishedAt: toDate(r.maxFinishedAt),
+      sumAttempts: Number(r.sumAttempts)
+    }));
+  }
+  /** One run's checkpoints matching `query`, in `seq` order and paged in SQL — the read the run
+  *  detail uses for a fan's failures, its folded checkpoints and one page of members. An empty
+  *  `statuses`/`namePrefixes` matches nothing; an empty `excludeGroups` excludes nothing. */
+  async queryCheckpoints(runId, query) {
+    if (query.statuses?.length === 0 || query.namePrefixes?.length === 0) return [];
+    const qb = this.checkpoints().createQueryBuilder("cp").where("cp.runId = :runId", {
+      runId
+    });
+    if (query.group !== void 0) qb.andWhere("cp.parallelGroup = :group", {
+      group: query.group
+    });
+    if (query.excludeGroups?.length) {
+      qb.andWhere("(cp.parallelGroup IS NULL OR cp.parallelGroup NOT IN (:...excludeGroups))", {
+        excludeGroups: query.excludeGroups
+      });
+    }
+    if (query.statuses) qb.andWhere("cp.status IN (:...statuses)", {
+      statuses: query.statuses
+    });
+    if (query.namePrefixes) {
+      const prefixes = query.namePrefixes.map((p) => `${p.replace(/[!%_]/g, "!$&")}%`);
+      const branches = prefixes.map((_, i) => `cp.name LIKE :namePrefix${i} ESCAPE '!'`);
+      qb.andWhere(`(${branches.join(" OR ")})`, Object.fromEntries(prefixes.map((p, i) => [
+        `namePrefix${i}`,
+        p
+      ])));
+    }
+    qb.orderBy("cp.seq", "ASC");
+    if (query.offset != null) qb.offset(query.offset);
+    if (query.limit != null || query.offset != null) {
+      qb.limit(query.limit ?? Number.MAX_SAFE_INTEGER);
+    }
+    return (await qb.getMany()).map(fromCheckpointEntity);
   }
   async putSignalWaiter(waiter) {
     await this.waiters().save({
@@ -1431,7 +1536,7 @@ var TypeOrmStateStore = class {
         token: (0, import_typeorm2.Like)(`${prefix}%`)
       }
     });
-    return rows.map((e) => ({
+    return rows.filter((e) => e.token.startsWith(prefix)).map((e) => ({
       token: e.token,
       runId: e.runId,
       seq: e.seq,
@@ -1722,6 +1827,23 @@ function fromScheduleEntity(e) {
   };
 }
 __name(fromScheduleEntity, "fromScheduleEntity");
+async function updateIfPending(repo, checkpoint) {
+  const { runId, seq, ...data } = toCheckpointEntity(checkpoint);
+  const set = {
+    ...data,
+    wakeAt: checkpoint.wakeAt != null ? new Date(checkpoint.wakeAt) : () => "NULL"
+  };
+  for (const key of Object.keys(set)) {
+    if (set[key] === void 0) delete set[key];
+  }
+  const result = await repo.createQueryBuilder().update().set(set).where({
+    runId,
+    seq,
+    status: "pending"
+  }).execute();
+  return (result.affected ?? 0) > 0;
+}
+__name(updateIfPending, "updateIfPending");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BufferedEventEntity,