@dudousxd/nestjs-durable-store-typeorm 0.19.0 → 0.20.0

package/dist/index.cjs

@@ -417,6 +417,14 @@ function durableEntities(options = {}) {
     name: "SignalWaiterEntity",
     target: SignalWaiterEntity,
     tableName: "durable_signal_waiters",
+    indices: [
+      {
+        name: "durable_signal_waiters_run_id_idx",
+        columns: [
+          "runId"
+        ]
+      }
+    ],
     columns: {
       token: {
         type: "text",
@@ -832,6 +840,11 @@ async function ensureTypeOrmDurableSchema(dataSource) {
         "durable_runs_namespace_status_idx",
         `${runs} (${runsCol("namespace")}, ${runsCol("status")}, ${runsCol("createdAt")})`
       ],
+      // A run's waiters: the `ctx.all` join barrier probes them once per settled child.
+      [
+        "durable_signal_waiters_run_id_idx",
+        `${waiters} (${waiterCol("runId")})`
+      ],
       // buffered signals are taken FIFO per token (smallest id) — index the token for the scan.
       [
         "durable_buffered_signals_token_idx",
@@ -886,6 +899,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 sqliteSingletonClaims = /* @__PURE__ */ new WeakMap();
 var TypeOrmStateStore = class {
   static {
     __name(this, "TypeOrmStateStore");
@@ -928,11 +942,63 @@ var TypeOrmStateStore = class {
     const rows = (0, import_nestjs_durable_core.normalizeAttributeRows)(runId, attributes);
     if (rows.length) await repo.insert(rows);
   }
+  async tryAdmitSingleton(runId, tag, workflow, limit, retryWakeAt) {
+    const previous = sqliteSingletonClaims.get(this.dataSource) ?? Promise.resolve();
+    const sqlite = [
+      "sqlite",
+      "better-sqlite3",
+      "sqljs"
+    ].includes(this.dataSource.options.type);
+    let release;
+    if (sqlite) {
+      const next = new Promise((resolve) => {
+        release = resolve;
+      });
+      sqliteSingletonClaims.set(this.dataSource, previous.then(() => next));
+      await previous;
+    }
+    try {
+      return await this.dataSource.transaction(async (em) => {
+        const repo = em.getRepository(WorkflowRunEntity);
+        const where = {
+          workflow,
+          status: (0, import_typeorm2.In)(import_nestjs_durable_core.SINGLETON_ACTIVE_STATUSES)
+        };
+        await repo.update(where, {
+          workflow
+        });
+        const runs = (await repo.find({
+          where
+        })).map(fromRunEntity);
+        const tags = (0, import_nestjs_durable_core.singletonAdmissionTags)(runs, runId, tag, workflow, limit);
+        if (!tags) {
+          const patch = (0, import_nestjs_durable_core.singletonAdmissionDenialPatch)(runs, runId, tag, workflow, retryWakeAt);
+          if (patch) await repo.update({
+            id: runId
+          }, {
+            status: "suspended",
+            wakeAt: new Date(patch.wakeAt),
+            updatedAt: patch.updatedAt
+          });
+          return false;
+        }
+        await repo.update({
+          id: runId
+        }, {
+          tags
+        });
+        return true;
+      });
+    } finally {
+      release?.();
+    }
+  }
   async createRun(run) {
     await this.runs().save(toRunEntity(run));
     await this.reindexAttributes(run.id, run.searchAttributes);
   }
-  async updateRun(runId, patch) {
+  async updateRun(runId, inputPatch) {
+    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.getRun(id)) : inputPatch;
     const update = {};
     if ("workflow" in patch) update.workflow = patch.workflow;
     if ("workflowVersion" in patch) update.workflowVersion = patch.workflowVersion;
@@ -1364,6 +1430,71 @@ var TypeOrmStateStore = class {
       parallelGroup: e.parallelGroup ?? void 0
     }));
   }
+  async registerChildWaits(entries) {
+    if (entries.length === 0) return;
+    await this.dataSource.transaction(async (em) => {
+      await em.getRepository(SignalWaiterEntity).upsert(entries.map(({ waiter }) => ({
+        token: waiter.token,
+        runId: waiter.runId,
+        seq: waiter.seq,
+        parallelGroup: waiter.parallelGroup ?? null
+      })), [
+        "token"
+      ]);
+      await em.getRepository(StepCheckpointEntity).upsert(entries.map(({ checkpoint }) => toCheckpointEntity(checkpoint)), [
+        "runId",
+        "seq"
+      ]);
+    });
+  }
+  async compactCheckpoints(runId, fromSeq, toSeq, into) {
+    await this.dataSource.transaction(async (em) => {
+      const checkpoints = em.getRepository(StepCheckpointEntity);
+      await checkpoints.delete({
+        runId,
+        seq: (0, import_typeorm2.Between)(fromSeq, toSeq)
+      });
+      await checkpoints.upsert(toCheckpointEntity(into), [
+        "runId",
+        "seq"
+      ]);
+    });
+  }
+  async listSignalWaitersByRun(runIds) {
+    if (runIds.length === 0) return [];
+    const rows = await this.waiters().find({
+      where: {
+        runId: (0, import_typeorm2.In)(runIds)
+      }
+    });
+    return rows.map((e) => ({
+      token: e.token,
+      runId: e.runId,
+      seq: e.seq,
+      parallelGroup: e.parallelGroup ?? void 0
+    }));
+  }
+  async hasSignalWaiter(runId, tokenPrefix) {
+    const where = {
+      runId,
+      token: (0, import_typeorm2.Like)(`${tokenPrefix}%`)
+    };
+    const first = await this.waiters().findOne({
+      where,
+      select: {
+        token: true
+      }
+    });
+    if (!first) return false;
+    if (first.token.startsWith(tokenPrefix)) return true;
+    const rows = await this.waiters().find({
+      where,
+      select: {
+        token: true
+      }
+    });
+    return rows.some((r) => r.token.startsWith(tokenPrefix));
+  }
   async takeSignalWaiter(token) {
     const e = await this.waiters().findOneBy({
       token