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

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",
@@ -1133,12 +1146,20 @@ var TypeOrmStateStore = class {
     });
     return rows.map(fromRunEntity);
   }
-  async listDueTimers(nowMs, namespace) {
-    const rows = await this.runs().findBy({
-      status: "suspended",
-      wakeAt: (0, import_typeorm2.LessThanOrEqual)(new Date(nowMs)),
-      ...namespace !== void 0 ? {
-        namespace
+  async listDueTimers(nowMs, namespace, limit) {
+    const rows = await this.runs().find({
+      where: {
+        status: "suspended",
+        wakeAt: (0, import_typeorm2.LessThanOrEqual)(new Date(nowMs)),
+        ...namespace !== void 0 ? {
+          namespace
+        } : {}
+      },
+      order: {
+        wakeAt: "ASC"
+      },
+      ...limit !== void 0 ? {
+        take: limit
       } : {}
     });
     return rows.map(fromRunEntity);
@@ -1417,6 +1438,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