@dudousxd/nestjs-durable-store-mikro-orm 0.29.0 → 0.30.0

package/dist/index.cjs

@@ -379,6 +379,19 @@ function durableEntities(options = {}) {
     class: StepCheckpointEntity,
     tableName: "durable_step_checkpoints",
     repository: /* @__PURE__ */ __name(() => StepCheckpointRepository, "repository"),
+    // `(runId, parallelGroup, seq)` serves the run detail's per-group reads — `checkpointStats` with a
+    // group and `queryCheckpoints` paging one fan in `seq` order — without scanning the whole run.
+    // Mirrors the Prisma adapter's index of the same name.
+    indexes: [
+      {
+        name: "durable_step_checkpoints_group_idx",
+        properties: [
+          "runId",
+          "parallelGroup",
+          "seq"
+        ]
+      }
+    ],
     properties: {
       runId: {
         type: "string",
@@ -1120,6 +1133,25 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     });
     return affected > 0;
   }
+  async saveCheckpointsIfPending(checkpoints) {
+    if (checkpoints.length === 0) return [];
+    return this.fork().transactional(async (em) => {
+      const wrote = [];
+      for (const checkpoint of checkpoints) {
+        const { runId: _runId, seq: _seq, ...data } = toCheckpointEntity(checkpoint);
+        const affected = await em.nativeUpdate(StepCheckpointEntity, {
+          runId: checkpoint.runId,
+          seq: checkpoint.seq,
+          status: "pending"
+        }, {
+          ...data,
+          wakeAt: checkpoint.wakeAt != null ? new Date(checkpoint.wakeAt) : null
+        });
+        wrote.push(affected > 0);
+      }
+      return wrote;
+    });
+  }
   async transaction(work) {
     return this.fork().transactional(async (em) => work({
       raw: em,
@@ -1640,6 +1672,103 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
         seq: "asc"
       }
     });
+    return rows.filter((r) => prefixes.some((p) => r.name.startsWith(p))).map(fromCheckpointEntity);
+  }
+  /** One `GROUP BY parallel_group, status, <name kind>` over the run's checkpoints — the buckets a
+  *  run detail summarizes a fan from, without loading its rows. The name-kind `CASE` is the SQL of
+  *  `checkpointNameKind`, and `min(coalesce(enqueued_at, started_at))` reads `enqueuedAt` the way
+  *  {@link listCheckpoints} does. Raw SQL on metadata-resolved names, so a custom column naming
+  *  strategy is honoured. */
+  async checkpointStats(runId, opts) {
+    const em = this.fork();
+    const quote = this.idQuote(em);
+    const meta = em.getMetadata().get(StepCheckpointEntity);
+    const c = /* @__PURE__ */ __name((prop) => quote(meta.properties[prop]?.fieldNames?.[0] ?? prop), "c");
+    const nameKind = `case when ${c("name")} like 'signal:child:%' then 'child' when ${c("name")} like 'fan:%' then 'folded' when ${c("name")} like 'spawn:%' then 'spawn' else 'step' end`;
+    const params = [
+      runId
+    ];
+    let where = `${c("runId")} = ?`;
+    if (opts?.group !== void 0) {
+      where += ` and ${c("parallelGroup")} = ?`;
+      params.push(opts.group);
+    }
+    const sql = `select ${c("parallelGroup")} as ${quote("grp")}, ${c("status")} as ${quote("status")}, ${nameKind} as ${quote("name_kind")}, count(*) as ${quote("n")}, min(${c("seq")}) as ${quote("min_seq")}, max(${c("seq")}) as ${quote("max_seq")}, min(${c("name")}) as ${quote("min_name")}, max(${c("name")}) as ${quote("max_name")}, min(coalesce(${c("enqueuedAt")}, ${c("startedAt")})) as ${quote("min_enqueued_at")}, min(${c("startedAt")}) as ${quote("min_started_at")}, max(${c("startedAt")}) as ${quote("max_started_at")}, max(${c("finishedAt")}) as ${quote("max_finished_at")}, sum(${c("attempts")}) as ${quote("sum_attempts")} from ${quote(meta.tableName)} where ${where} group by ${c("parallelGroup")}, ${c("status")}, ${nameKind}`;
+    const rows = await em.getConnection().execute(sql, params);
+    const date = aggregateDateReader(em);
+    return rows.map((row) => ({
+      group: row.grp ?? null,
+      status: row.status,
+      nameKind: row.name_kind,
+      count: Number(row.n),
+      minSeq: Number(row.min_seq),
+      maxSeq: Number(row.max_seq),
+      minName: String(row.min_name),
+      maxName: String(row.max_name),
+      minEnqueuedAt: date(row.min_enqueued_at),
+      minStartedAt: date(row.min_started_at),
+      maxStartedAt: date(row.max_started_at),
+      maxFinishedAt: date(row.max_finished_at),
+      sumAttempts: Number(row.sum_attempts)
+    }));
+  }
+  /** The run's checkpoints matching `query`, in `seq` order and paged in the database — a fan's
+  *  failures or one page of its members without the rest of the run. An excluded group keeps the
+  *  ungrouped rows (`parallel_group is null or not in (...)`); an empty `statuses`/`namePrefixes`
+  *  matches nothing, so it returns before querying. */
+  async queryCheckpoints(runId, query) {
+    if (query.statuses?.length === 0 || query.namePrefixes?.length === 0) return [];
+    const and = [
+      {
+        runId
+      }
+    ];
+    if (query.group !== void 0) and.push({
+      parallelGroup: query.group
+    });
+    if (query.excludeGroups?.length) {
+      and.push({
+        $or: [
+          {
+            parallelGroup: null
+          },
+          {
+            parallelGroup: {
+              $nin: query.excludeGroups
+            }
+          }
+        ]
+      });
+    }
+    if (query.statuses) and.push({
+      status: {
+        $in: query.statuses
+      }
+    });
+    if (query.namePrefixes) {
+      and.push({
+        $or: query.namePrefixes.map((p) => ({
+          name: {
+            $like: `${p}%`
+          }
+        }))
+      });
+    }
+    const rows = await this.fork().find(StepCheckpointEntity, {
+      $and: and
+    }, {
+      orderBy: {
+        seq: "asc"
+      },
+      // An offset alone is not valid SQL on SQLite/MySQL, so an unbounded page gets a limit no
+      // run reaches.
+      ...query.limit !== void 0 || query.offset ? {
+        limit: query.limit ?? Number.MAX_SAFE_INTEGER
+      } : {},
+      ...query.offset ? {
+        offset: query.offset
+      } : {}
+    });
     return rows.map(fromCheckpointEntity);
   }
   async putSignalWaiter(waiter) {
@@ -1674,7 +1803,7 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
         $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,
@@ -1856,6 +1985,21 @@ function fromRunEntity(e) {
   };
 }
 __name(fromRunEntity, "fromRunEntity");
+function aggregateDateReader(em) {
+  const platform = em.getPlatform();
+  const tz = platform.getTimezone();
+  return (value) => {
+    if (value instanceof Date) return value;
+    if (typeof value === "bigint") return platform.parseDate(Number(value));
+    if (typeof value === "number" || !tz || tz === "local") {
+      return platform.parseDate(value);
+    }
+    const text = String(value);
+    const zoned = text.includes("+") || text.lastIndexOf("-") > 10 || text.endsWith("Z");
+    return platform.parseDate(zoned ? text : `${text}${tz}`);
+  };
+}
+__name(aggregateDateReader, "aggregateDateReader");
 function toCheckpointEntity(cp) {
   const e = new StepCheckpointEntity();
   e.runId = cp.runId;