@dudousxd/nestjs-durable-store-mikro-orm 0.29.0 → 0.31.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",
@@ -998,6 +1011,30 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     await em.flush();
     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 && import_nestjs_durable_core.TERMINAL_RUN_STATUSES.includes(inputPatch.status) ? await (0, import_nestjs_durable_core.clearTerminalSingletonAdmission)(runId, inputPatch, (id) => this.withScope({}).getRun(id)) : inputPatch;
+    const data = runUpdateData(patch);
+    const em = this.fork();
+    let applied;
+    if (Object.keys(data).length) {
+      applied = await em.nativeUpdate(WorkflowRunEntity, {
+        id: runId,
+        status: {
+          $in: expectedStatuses
+        }
+      }, data) > 0;
+    } else {
+      applied = await em.count(WorkflowRunEntity, {
+        id: runId,
+        status: {
+          $in: expectedStatuses
+        }
+      }) > 0;
+    }
+    if (applied && "searchAttributes" in patch) await this.reindexAttributes(runId, patch.searchAttributes);
+    return applied;
+  }
   /** 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, forked) {
@@ -1120,6 +1157,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,
@@ -1143,6 +1199,37 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     });
     return rows.map(fromRunEntity);
   }
+  async listOrphanedRuns(nowMs, limit, namespace) {
+    if (limit <= 0) return [];
+    const em = this.fork();
+    const rows = await em.find(WorkflowRunEntity, {
+      status: {
+        $in: [
+          "running",
+          "cancelling"
+        ]
+      },
+      $or: [
+        {
+          lockedUntil: null
+        },
+        {
+          lockedUntil: {
+            $lte: new Date(nowMs)
+          }
+        }
+      ],
+      ...namespace !== void 0 ? {
+        namespace
+      } : {}
+    }, {
+      orderBy: {
+        createdAt: "ASC"
+      },
+      limit
+    });
+    return rows.map(fromRunEntity);
+  }
   async listPendingRuns(limit, namespace) {
     const em = this.fork();
     const rows = await em.find(WorkflowRunEntity, {
@@ -1640,6 +1727,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 +1858,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,
@@ -1807,6 +1991,29 @@ var MikroOrmStateStore = class _MikroOrmStateStore {
     return affected > 0;
   }
 };
+function runUpdateData(patch) {
+  const data = {};
+  if ("workflow" in patch) data.workflow = patch.workflow;
+  if ("workflowVersion" in patch) data.workflowVersion = patch.workflowVersion;
+  if ("status" in patch) data.status = patch.status;
+  if ("input" in patch) data.input = patch.input ?? null;
+  if ("output" in patch) data.output = patch.output ?? null;
+  if ("error" in patch) data.error = patch.error ?? null;
+  if ("wakeAt" in patch) data.wakeAt = patch.wakeAt == null ? null : new Date(patch.wakeAt);
+  if ("lockedBy" in patch) data.lockedBy = patch.lockedBy ?? null;
+  if ("lockedUntil" in patch) data.lockedUntil = patch.lockedUntil == null ? null : new Date(patch.lockedUntil);
+  if ("awaitingDecisionTaskId" in patch) data.awaitingDecisionTaskId = patch.awaitingDecisionTaskId ?? null;
+  if ("recoveryAttempts" in patch) data.recoveryAttempts = patch.recoveryAttempts ?? null;
+  if ("tags" in patch) data.tags = patch.tags ?? null;
+  if ("searchAttributes" in patch) data.searchAttributes = patch.searchAttributes ?? null;
+  if ("priority" in patch) data.priority = patch.priority ?? null;
+  if ("namespace" in patch) data.namespace = patch.namespace ?? "default";
+  if ("origin" in patch) data.origin = patch.origin ?? null;
+  if (patch.createdAt != null) data.createdAt = patch.createdAt;
+  if (patch.updatedAt != null) data.updatedAt = patch.updatedAt;
+  return data;
+}
+__name(runUpdateData, "runUpdateData");
 function toRunEntity(run) {
   const e = new WorkflowRunEntity();
   e.id = run.id;
@@ -1856,6 +2063,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;