@dudousxd/nestjs-durable-store-typeorm 0.26.0 → 0.27.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs CHANGED
@@ -29,6 +29,7 @@ __export(index_exports, {
29
29
  MYSQL_DATETIME_TYPE: () => MYSQL_DATETIME_TYPE,
30
30
  RunAttributeEntity: () => RunAttributeEntity,
31
31
  ScheduleEntity: () => ScheduleEntity,
32
+ SignalIdEntity: () => SignalIdEntity,
32
33
  SignalWaiterEntity: () => SignalWaiterEntity,
33
34
  StepCheckpointEntity: () => StepCheckpointEntity,
34
35
  TypeOrmStateStore: () => TypeOrmStateStore,
@@ -157,6 +158,15 @@ var BufferedEventEntity = class {
157
158
  payload;
158
159
  publishedAt;
159
160
  };
161
+ var SignalIdEntity = class {
162
+ static {
163
+ __name(this, "SignalIdEntity");
164
+ }
165
+ token;
166
+ signalId;
167
+ /** Epoch ms as a `bigint` (drivers hand it back as a string): exact, unlike a DATETIME. */
168
+ expiresAt;
169
+ };
160
170
  var ScheduleEntity = class {
161
171
  static {
162
172
  __name(this, "ScheduleEntity");
@@ -521,6 +531,29 @@ function durableEntities(options = {}) {
521
531
  }
522
532
  }
523
533
  });
534
+ const signalIds = new import_typeorm.EntitySchema({
535
+ name: "SignalIdEntity",
536
+ target: SignalIdEntity,
537
+ tableName: "durable_signal_ids",
538
+ // Its `(token, signal_id)` key and `expires_at` index are raw DDL in `schema.ts`, like every
539
+ // other durable table's.
540
+ columns: {
541
+ token: {
542
+ type: "text",
543
+ primary: true,
544
+ name: col("token")
545
+ },
546
+ signalId: {
547
+ type: "text",
548
+ primary: true,
549
+ name: col("signalId")
550
+ },
551
+ expiresAt: {
552
+ type: "bigint",
553
+ name: col("expiresAt")
554
+ }
555
+ }
556
+ });
524
557
  const schedules = new import_typeorm.EntitySchema({
525
558
  name: "ScheduleEntity",
526
559
  target: ScheduleEntity,
@@ -583,6 +616,7 @@ function durableEntities(options = {}) {
583
616
  signalWaiters,
584
617
  bufferedSignals,
585
618
  bufferedEvents,
619
+ signalIds,
586
620
  schedules
587
621
  ];
588
622
  }
@@ -635,6 +669,7 @@ var TABLE_TO_ENTITY = {
635
669
  durable_signal_waiters: SignalWaiterEntity,
636
670
  durable_buffered_signals: BufferedSignalEntity,
637
671
  durable_buffered_events: BufferedEventEntity,
672
+ durable_signal_ids: SignalIdEntity,
638
673
  durable_schedules: ScheduleEntity
639
674
  };
640
675
  function durableManagedTables() {
@@ -717,6 +752,8 @@ async function ensureTypeOrmDurableSchema(dataSource, options = {}) {
717
752
  const bevCol = /* @__PURE__ */ __name((property) => q(resolve("durable_buffered_events", property)), "bevCol");
718
753
  const schedules = q("durable_schedules");
719
754
  const schCol = /* @__PURE__ */ __name((property) => q(resolve("durable_schedules", property)), "schCol");
755
+ const signalIds = q("durable_signal_ids");
756
+ const sidCol = /* @__PURE__ */ __name((property) => q(resolve("durable_signal_ids", property)), "sidCol");
720
757
  const num = isPg ? "double precision" : isMysql ? "double" : "real";
721
758
  const bufferedId = isSqlite ? `${bufCol("id")} integer PRIMARY KEY AUTOINCREMENT` : isMysql ? `${bufCol("id")} bigint NOT NULL AUTO_INCREMENT PRIMARY KEY` : isPg ? `${bufCol("id")} bigserial PRIMARY KEY` : `${bufCol("id")} bigint NOT NULL AUTO_INCREMENT PRIMARY KEY`;
722
759
  const tables = [
@@ -779,6 +816,16 @@ async function ensureTypeOrmDurableSchema(dataSource, options = {}) {
779
816
  ${bevCol("payload")} ${txt}, ${bevCol("publishedAt")} ${ts} NOT NULL
780
817
  )`
781
818
  ],
819
+ // Signal dedupe ids (`signal(..., { id })`): one row per (token, id) until `expires_at` (epoch
820
+ // ms as a bigint — exact, unlike a MySQL DATETIME).
821
+ [
822
+ "durable_signal_ids",
823
+ `CREATE TABLE IF NOT EXISTS ${signalIds} (
824
+ ${sidCol("token")} ${str} NOT NULL, ${sidCol("signalId")} ${str} NOT NULL,
825
+ ${sidCol("expiresAt")} bigint NOT NULL,
826
+ PRIMARY KEY (${sidCol("token")}, ${sidCol("signalId")})
827
+ )`
828
+ ],
782
829
  // Persisted schedules. `next_fire_at` is epoch ms as a bigint (exact, so the compare-and-set on
783
830
  // it survives MySQL's DATETIME millisecond truncation); `spec`/`state` are engine-owned JSON.
784
831
  [
@@ -998,6 +1045,12 @@ async function ensureTypeOrmDurableSchema(dataSource, options = {}) {
998
1045
  `${bufferedEvents} (${bevCol("name")}, ${bevCol("publishedAt")})`,
999
1046
  "durable_buffered_events"
1000
1047
  ],
1048
+ // The expired-signal-id sweep (`expires_at <= now`).
1049
+ [
1050
+ "durable_signal_ids_expires_at_idx",
1051
+ `${signalIds} (${sidCol("expiresAt")})`,
1052
+ "durable_signal_ids"
1053
+ ],
1001
1054
  // Search-attribute pushdown: equality + range predicates probe by (key, value). Two composite
1002
1055
  // indexes — one per typed column — so a numeric range or a string equality is an index scan.
1003
1056
  // Persisted schedules: the poll's "due by T" scan (`paused = false AND next_fire_at <= T`).
@@ -1101,9 +1154,25 @@ var TypeOrmStateStore = class {
1101
1154
  }
1102
1155
  dataSource;
1103
1156
  options;
1157
+ // The round-trip-saving optional methods, bound per dialect where they save a statement (see
1158
+ // `TypeOrmRoundTrips`); absent on SQLite, where the engine's read-then-write calls are used.
1159
+ settleResultsIfPending;
1160
+ insertCheckpointIfAbsent;
1161
+ tryLockRunAndGet;
1162
+ claimPendingRuns;
1104
1163
  constructor(dataSource, options = {}) {
1105
1164
  this.dataSource = dataSource;
1106
1165
  this.options = options;
1166
+ const type = String(dataSource.options.type);
1167
+ const dialect = type === "postgres" ? "postgres" : type === "mysql" ? "mysql" : void 0;
1168
+ if (!dialect) return;
1169
+ const fast = new TypeOrmRoundTrips(dataSource, dialect, this);
1170
+ this.insertCheckpointIfAbsent = (cp) => fast.insertCheckpointIfAbsent(cp);
1171
+ this.settleResultsIfPending = (results) => fast.settleResultsIfPending(results);
1172
+ this.claimPendingRuns = (limit, owner, until, now, ns) => fast.claimPendingRuns(limit, owner, until, now, ns);
1173
+ if (dialect === "postgres") {
1174
+ this.tryLockRunAndGet = (runId, owner, until, now) => fast.tryLockRunAndGet(runId, owner, until, now);
1175
+ }
1107
1176
  }
1108
1177
  async ensureSchema() {
1109
1178
  await ensureTypeOrmDurableSchema(this.dataSource, {
@@ -1126,6 +1195,9 @@ var TypeOrmStateStore = class {
1126
1195
  bufferedEvents() {
1127
1196
  return this.dataSource.getRepository(BufferedEventEntity);
1128
1197
  }
1198
+ signalIds() {
1199
+ return this.dataSource.getRepository(SignalIdEntity);
1200
+ }
1129
1201
  attributes() {
1130
1202
  return this.dataSource.getRepository(RunAttributeEntity);
1131
1203
  }
@@ -1408,6 +1480,24 @@ var TypeOrmStateStore = class {
1408
1480
  }
1409
1481
  async settleCheckpointsIfPending(settlements) {
1410
1482
  if (settlements.length === 0) return [];
1483
+ if (settlements.length === 1) {
1484
+ const s = settlements[0];
1485
+ const result = await this.checkpoints().createQueryBuilder().update().set({
1486
+ status: s.status,
1487
+ output: s.output ?? null,
1488
+ error: s.error ?? null,
1489
+ events: s.events ?? null,
1490
+ startedAt: s.startedAt,
1491
+ finishedAt: s.finishedAt
1492
+ }).where({
1493
+ runId: s.runId,
1494
+ seq: s.seq,
1495
+ status: "pending"
1496
+ }).execute();
1497
+ return [
1498
+ result.affected === 1
1499
+ ];
1500
+ }
1411
1501
  return this.dataSource.transaction(async (em) => {
1412
1502
  const repo = em.getRepository(StepCheckpointEntity);
1413
1503
  const pending = await this.lockPendingCheckpoints(repo, settlements, [
@@ -2098,6 +2188,87 @@ var TypeOrmStateStore = class {
2098
2188
  payload: e.payload ?? void 0
2099
2189
  };
2100
2190
  }
2191
+ async takeOldestBufferedSignal(tokens) {
2192
+ if (tokens.length === 0) return null;
2193
+ const unique = [
2194
+ ...new Set(tokens)
2195
+ ];
2196
+ for (; ; ) {
2197
+ const e = await this.buffered().findOne({
2198
+ where: {
2199
+ token: (0, import_typeorm2.In)(unique)
2200
+ },
2201
+ order: {
2202
+ id: "ASC"
2203
+ }
2204
+ });
2205
+ if (!e) return null;
2206
+ const deleted = await this.buffered().delete({
2207
+ id: e.id
2208
+ });
2209
+ if (deleted.affected === 1) return {
2210
+ token: e.token,
2211
+ payload: e.payload ?? void 0
2212
+ };
2213
+ }
2214
+ }
2215
+ async claimSignalId(token, id, expiresAt, nowMs) {
2216
+ for (; ; ) {
2217
+ try {
2218
+ await this.signalIds().insert({
2219
+ token,
2220
+ signalId: id,
2221
+ expiresAt
2222
+ });
2223
+ return true;
2224
+ } catch (err) {
2225
+ if (!isUniqueViolation(err)) throw err;
2226
+ }
2227
+ const taken = await this.signalIds().update({
2228
+ token,
2229
+ signalId: id,
2230
+ expiresAt: (0, import_typeorm2.LessThanOrEqual)(nowMs)
2231
+ }, {
2232
+ expiresAt
2233
+ });
2234
+ if (taken.affected === 1) return true;
2235
+ if (await this.signalIds().exists({
2236
+ where: {
2237
+ token,
2238
+ signalId: id
2239
+ }
2240
+ })) return false;
2241
+ }
2242
+ }
2243
+ async releaseSignalId(token, id) {
2244
+ await this.signalIds().delete({
2245
+ token,
2246
+ signalId: id
2247
+ });
2248
+ }
2249
+ async deleteExpiredSignalIds(nowMs, limit) {
2250
+ const rows = await this.signalIds().find({
2251
+ select: {
2252
+ token: true,
2253
+ signalId: true
2254
+ },
2255
+ where: {
2256
+ expiresAt: (0, import_typeorm2.LessThanOrEqual)(nowMs)
2257
+ },
2258
+ take: limit
2259
+ });
2260
+ if (rows.length === 0) return 0;
2261
+ const result = await this.signalIds().delete({
2262
+ token: (0, import_typeorm2.In)([
2263
+ ...new Set(rows.map((r) => r.token))
2264
+ ]),
2265
+ signalId: (0, import_typeorm2.In)([
2266
+ ...new Set(rows.map((r) => r.signalId))
2267
+ ]),
2268
+ expiresAt: (0, import_typeorm2.LessThanOrEqual)(nowMs)
2269
+ });
2270
+ return result.affected ?? rows.length;
2271
+ }
2101
2272
  async listBufferedSignals(tokenPrefix, afterId, limit) {
2102
2273
  const rows = await this.buffered().find({
2103
2274
  where: {
@@ -2383,6 +2554,251 @@ async function updateIfPending(repo, checkpoint) {
2383
2554
  return (result.affected ?? 0) > 0;
2384
2555
  }
2385
2556
  __name(updateIfPending, "updateIfPending");
2557
+ function isUniqueViolation(err) {
2558
+ const driverError = err?.driverError ?? err;
2559
+ const e = driverError;
2560
+ const code = String(e?.code ?? "");
2561
+ return code === "23505" || code === "ER_DUP_ENTRY" || e?.errno === 1062 || code.startsWith("SQLITE_CONSTRAINT");
2562
+ }
2563
+ __name(isUniqueViolation, "isUniqueViolation");
2564
+ var TypeOrmRoundTrips = class TypeOrmRoundTrips2 {
2565
+ static {
2566
+ __name(this, "TypeOrmRoundTrips");
2567
+ }
2568
+ ds;
2569
+ store;
2570
+ pg;
2571
+ /** The checkpoint columns' actual Postgres types (what the schema created), read once. */
2572
+ cpTypes;
2573
+ constructor(ds, dialect, store) {
2574
+ this.ds = ds;
2575
+ this.store = store;
2576
+ this.pg = dialect === "postgres";
2577
+ }
2578
+ get runs() {
2579
+ return this.ds.getMetadata(WorkflowRunEntity);
2580
+ }
2581
+ get cps() {
2582
+ return this.ds.getMetadata(StepCheckpointEntity);
2583
+ }
2584
+ /**
2585
+ * The Postgres type to cast a `VALUES` parameter of checkpoint `property` to: the column's actual
2586
+ * type in the database (a `timestamptz` the schema helper created, or a `timestamp` from
2587
+ * `synchronize`), so the value converts exactly as the repository's own writes convert it.
2588
+ */
2589
+ async cpType(property) {
2590
+ this.cpTypes ??= this.ds.query("SELECT column_name AS name, data_type AS type FROM information_schema.columns WHERE table_name = $1 AND table_schema = current_schema()", [
2591
+ this.cps.tableName
2592
+ ]).then((rows) => new Map(rows.map((r) => [
2593
+ r.name,
2594
+ r.type
2595
+ ])));
2596
+ const column = this.col(this.cps, property);
2597
+ return (await this.cpTypes).get(column.databaseName) ?? this.ds.driver.normalizeType(column);
2598
+ }
2599
+ q(name) {
2600
+ return this.pg ? `"${name.replace(/"/g, '""')}"` : `\`${name.replace(/`/g, "``")}\``;
2601
+ }
2602
+ p(i) {
2603
+ return this.pg ? `$${i}` : "?";
2604
+ }
2605
+ col(meta, property) {
2606
+ const column = meta.findColumnWithPropertyName(property);
2607
+ if (!column) throw new Error(`no column for ${property}`);
2608
+ return column;
2609
+ }
2610
+ c(meta, property) {
2611
+ return this.q(this.col(meta, property).databaseName);
2612
+ }
2613
+ table(meta) {
2614
+ return this.q(meta.tableName);
2615
+ }
2616
+ /** `value` as the driver binds it for `property` (transformers and type conversion included). */
2617
+ bind(meta, property, value) {
2618
+ if (value == null) return null;
2619
+ return this.ds.driver.preparePersistentValue(value, this.col(meta, property));
2620
+ }
2621
+ /** A raw row as the repository would hydrate it; a column the row lacks reads `null`. */
2622
+ hydrate(meta, raw) {
2623
+ const entity = {};
2624
+ for (const column of meta.columns) {
2625
+ const value = raw[column.databaseName];
2626
+ entity[column.propertyName] = value === void 0 ? null : this.ds.driver.prepareHydratedValue(value, column);
2627
+ }
2628
+ return entity;
2629
+ }
2630
+ /** Rows of a statement: Postgres `UPDATE … RETURNING` comes back as `[rows, count]`. */
2631
+ rows(out) {
2632
+ if (Array.isArray(out) && Array.isArray(out[0])) return out[0];
2633
+ return Array.isArray(out) ? out : [];
2634
+ }
2635
+ cpColumns(withInput) {
2636
+ return this.cps.columns.filter((c) => withInput || c.propertyName !== "input");
2637
+ }
2638
+ async tryLockRunAndGet(runId, owner, leaseUntilMs, nowMs) {
2639
+ const r = this.runs;
2640
+ const until = this.c(r, "lockedUntil");
2641
+ const out = await this.ds.query(`UPDATE ${this.table(r)} SET ${this.c(r, "lockedBy")} = $1, ${until} = $2 WHERE ${this.c(r, "id")} = $3 AND (${until} IS NULL OR ${until} <= $4) RETURNING *`, [
2642
+ owner,
2643
+ this.bind(r, "lockedUntil", new Date(leaseUntilMs)),
2644
+ runId,
2645
+ this.bind(r, "lockedUntil", new Date(nowMs))
2646
+ ]);
2647
+ const [row] = this.rows(out);
2648
+ return row ? fromRunEntity(this.hydrate(r, row)) : null;
2649
+ }
2650
+ async insertCheckpointIfAbsent(checkpoint) {
2651
+ const entity = toCheckpointEntity(checkpoint);
2652
+ const columns = this.cps.columns;
2653
+ const names = columns.map((c) => this.q(c.databaseName)).join(", ");
2654
+ const values = columns.map((c) => this.bind(this.cps, c.propertyName, entity[c.propertyName]));
2655
+ const marks = columns.map((_, i) => this.p(i + 1)).join(", ");
2656
+ const insert = `INSERT INTO ${this.table(this.cps)} (${names}) VALUES (${marks})`;
2657
+ if (this.pg) {
2658
+ const key = `${this.c(this.cps, "runId")}, ${this.c(this.cps, "seq")}`;
2659
+ const out = await this.ds.query(`${insert} ON CONFLICT (${key}) DO NOTHING RETURNING ${this.c(this.cps, "seq")}`, values);
2660
+ return this.rows(out).length === 1;
2661
+ }
2662
+ try {
2663
+ await this.ds.query(insert, values);
2664
+ return true;
2665
+ } catch (err) {
2666
+ const driver = err.driverError;
2667
+ if (driver?.errno === 1062 || driver?.code === "ER_DUP_ENTRY") return false;
2668
+ throw err;
2669
+ }
2670
+ }
2671
+ async settleResultsIfPending(results) {
2672
+ const out = results.map(() => null);
2673
+ const seen = /* @__PURE__ */ new Set();
2674
+ const sent = results.flatMap((r2, i) => {
2675
+ const key = checkpointKey(r2.runId, r2.seq);
2676
+ if (seen.has(key)) return [];
2677
+ seen.add(key);
2678
+ return [
2679
+ i
2680
+ ];
2681
+ });
2682
+ if (sent.length === 0) return out;
2683
+ if (!this.pg) {
2684
+ if (sent.length > 1) return (0, import_nestjs_durable_core.settleResultsWithPlainCalls)(this.store, results);
2685
+ const only = sent[0];
2686
+ out[only] = await this.settleOneMysql(results[only]);
2687
+ return out;
2688
+ }
2689
+ const k = this.cps;
2690
+ const r = this.runs;
2691
+ const props = [
2692
+ "runId",
2693
+ "seq",
2694
+ "status",
2695
+ "output",
2696
+ "error",
2697
+ "events",
2698
+ "startedAt",
2699
+ "finishedAt"
2700
+ ];
2701
+ const types = new Map(await Promise.all(props.map(async (prop) => [
2702
+ prop,
2703
+ await this.cpType(prop)
2704
+ ])));
2705
+ const type = /* @__PURE__ */ __name((property) => types.get(property), "type");
2706
+ for (let at = 0; at < sent.length; at += 500) {
2707
+ const chunk = sent.slice(at, at + 500);
2708
+ const values = [];
2709
+ const rows = chunk.map((i) => {
2710
+ const s = results[i];
2711
+ const n = values.length;
2712
+ values.push(s.runId, s.seq, s.status, this.bind(k, "output", s.status === "completed" ? s.output : null), this.bind(k, "error", s.error), this.bind(k, "events", s.events), this.bind(k, "startedAt", s.startedAt), this.bind(k, "finishedAt", s.finishedAt));
2713
+ const p = /* @__PURE__ */ __name((j) => `$${n + j}`, "p");
2714
+ return `(${p(1)}::${type("runId")}, ${p(2)}::${type("seq")}, ${p(3)}::${type("status")}, ${p(4)}::${type("output")}, ${p(5)}::${type("error")}, ${p(6)}::${type("events")}, ${p(7)}::${type("startedAt")}, ${p(8)}::${type("finishedAt")})`;
2715
+ });
2716
+ const c = /* @__PURE__ */ __name((prop) => this.c(k, prop), "c");
2717
+ const returning = this.cpColumns(false).map((col) => `c.${this.q(col.databaseName)}`).join(", ");
2718
+ const settled = this.rows(await this.ds.query(`UPDATE ${this.table(k)} AS c SET ${c("status")} = v.status, ${c("output")} = CASE WHEN v.status = 'completed' THEN v.output ELSE c.${c("output")} END, ${c("error")} = v.error, ${c("events")} = COALESCE(v.events, c.${c("events")}), ${c("startedAt")} = COALESCE(v.started_at, c.${c("startedAt")}), ${c("finishedAt")} = v.finished_at FROM (VALUES ${rows.join(", ")}) AS v(run_id, seq, status, output, error, events, started_at, finished_at) WHERE c.${c("runId")} = v.run_id AND c.${c("seq")} = v.seq AND c.${c("status")} = 'pending' AND NOT EXISTS (SELECT 1 FROM ${this.table(r)} AS r WHERE r.${this.c(r, "id")} = c.${c("runId")} AND r.${this.c(r, "status")} IN ('cancelled', 'completed')) RETURNING ${returning}`, values));
2719
+ const byKey = new Map(chunk.map((i) => {
2720
+ const s = results[i];
2721
+ return [
2722
+ checkpointKey(s.runId, s.seq),
2723
+ i
2724
+ ];
2725
+ }));
2726
+ for (const raw of settled) {
2727
+ const cp = fromCheckpointEntity(this.hydrate(k, raw));
2728
+ const i = byKey.get(checkpointKey(cp.runId, cp.seq));
2729
+ if (i !== void 0) out[i] = cp;
2730
+ }
2731
+ }
2732
+ return out;
2733
+ }
2734
+ async settleOneMysql(s) {
2735
+ const k = this.cps;
2736
+ const r = this.runs;
2737
+ const c = /* @__PURE__ */ __name((prop) => `c.${this.c(k, prop)}`, "c");
2738
+ const done = s.status === "completed";
2739
+ const result = await this.ds.query(`UPDATE ${this.table(k)} AS c SET ${c("status")} = ?, ${c("output")} = ${done ? "?" : c("output")}, ${c("error")} = ?, ${c("events")} = COALESCE(?, ${c("events")}), ${c("startedAt")} = COALESCE(?, ${c("startedAt")}), ${c("finishedAt")} = ? WHERE ${c("runId")} = ? AND ${c("seq")} = ? AND ${c("status")} = 'pending' AND NOT EXISTS (SELECT 1 FROM ${this.table(r)} AS r WHERE r.${this.c(r, "id")} = ${c("runId")} AND r.${this.c(r, "status")} IN ('cancelled', 'completed'))`, [
2740
+ s.status,
2741
+ ...done ? [
2742
+ this.bind(k, "output", s.output)
2743
+ ] : [],
2744
+ this.bind(k, "error", s.error),
2745
+ this.bind(k, "events", s.events),
2746
+ this.bind(k, "startedAt", s.startedAt),
2747
+ this.bind(k, "finishedAt", s.finishedAt),
2748
+ s.runId,
2749
+ s.seq
2750
+ ]);
2751
+ if (!result?.affectedRows) return null;
2752
+ const list = this.cpColumns(false).map((col) => this.q(col.databaseName)).join(", ");
2753
+ const [row] = this.rows(await this.ds.query(`SELECT ${list} FROM ${this.table(k)} WHERE ${this.c(k, "runId")} = ? AND ${this.c(k, "seq")} = ?`, [
2754
+ s.runId,
2755
+ s.seq
2756
+ ]));
2757
+ return row ? fromCheckpointEntity(this.hydrate(k, row)) : null;
2758
+ }
2759
+ async claimPendingRuns(limit, owner, leaseUntilMs, nowMs, namespace) {
2760
+ if (limit <= 0) return [];
2761
+ const r = this.runs;
2762
+ const c = /* @__PURE__ */ __name((prop) => this.c(r, prop), "c");
2763
+ const until = this.bind(r, "lockedUntil", new Date(leaseUntilMs));
2764
+ const now = this.bind(r, "lockedUntil", new Date(nowMs));
2765
+ const sort = /* @__PURE__ */ __name((runs) => runs.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id)), "sort");
2766
+ if (this.pg) {
2767
+ const ns = namespace !== void 0 ? ` AND ${c("namespace")} = $5` : "";
2768
+ const out = await this.ds.query(`WITH claimed AS MATERIALIZED (SELECT ${c("id")} AS claimed_id FROM ${this.table(r)} WHERE ${c("status")} = 'pending' AND (${c("lockedUntil")} IS NULL OR ${c("lockedUntil")} <= $3)${ns} ORDER BY ${c("createdAt")}, ${c("id")} LIMIT $4 FOR UPDATE SKIP LOCKED) UPDATE ${this.table(r)} AS r SET ${c("lockedBy")} = $1, ${c("lockedUntil")} = $2 FROM claimed WHERE r.${c("id")} = claimed.claimed_id RETURNING r.*`, [
2769
+ owner,
2770
+ until,
2771
+ now,
2772
+ limit,
2773
+ ...namespace !== void 0 ? [
2774
+ namespace
2775
+ ] : []
2776
+ ]);
2777
+ return sort(this.rows(out).map((raw) => fromRunEntity(this.hydrate(r, raw))));
2778
+ }
2779
+ return this.ds.transaction(async (em) => {
2780
+ const ns = namespace !== void 0 ? ` AND ${c("namespace")} = ?` : "";
2781
+ const picked = this.rows(await em.query(`SELECT * FROM ${this.table(r)} WHERE ${c("status")} = 'pending' AND (${c("lockedUntil")} IS NULL OR ${c("lockedUntil")} <= ?)${ns} ORDER BY ${c("createdAt")}, ${c("id")} LIMIT ? FOR UPDATE SKIP LOCKED`, [
2782
+ now,
2783
+ ...namespace !== void 0 ? [
2784
+ namespace
2785
+ ] : [],
2786
+ limit
2787
+ ])).map((raw) => fromRunEntity(this.hydrate(r, raw)));
2788
+ if (picked.length === 0) return [];
2789
+ await em.query(`UPDATE ${this.table(r)} SET ${c("lockedBy")} = ?, ${c("lockedUntil")} = ? WHERE ${c("id")} IN (${picked.map(() => "?").join(", ")})`, [
2790
+ owner,
2791
+ until,
2792
+ ...picked.map((run) => run.id)
2793
+ ]);
2794
+ return sort(picked.map((run) => ({
2795
+ ...run,
2796
+ lockedBy: owner,
2797
+ lockedUntil: leaseUntilMs
2798
+ })));
2799
+ });
2800
+ }
2801
+ };
2386
2802
  // Annotate the CommonJS export names for ESM import in node:
2387
2803
  0 && (module.exports = {
2388
2804
  BufferedEventEntity,
@@ -2393,6 +2809,7 @@ __name(updateIfPending, "updateIfPending");
2393
2809
  MYSQL_DATETIME_TYPE,
2394
2810
  RunAttributeEntity,
2395
2811
  ScheduleEntity,
2812
+ SignalIdEntity,
2396
2813
  SignalWaiterEntity,
2397
2814
  StepCheckpointEntity,
2398
2815
  TypeOrmStateStore,