@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 +417 -0
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +21 -2
- package/dist/index.d.ts +21 -2
- package/dist/index.js +417 -1
- package/dist/index.js.map +1 -1
- package/package.json +3 -3
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,
|