@dudousxd/nestjs-durable-store-prisma 0.24.2 → 0.24.4
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 +322 -37
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +6 -1
- package/dist/index.d.ts +6 -1
- package/dist/index.js +322 -37
- package/dist/index.js.map +1 -1
- package/package.json +5 -4
package/dist/index.cjs
CHANGED
|
@@ -279,6 +279,44 @@ var PrismaStateStore = class {
|
|
|
279
279
|
});
|
|
280
280
|
return row ? fromCheckpointRow(row) : null;
|
|
281
281
|
}
|
|
282
|
+
async getCheckpoints(runId, seqs) {
|
|
283
|
+
const unique = [
|
|
284
|
+
...new Set(seqs)
|
|
285
|
+
];
|
|
286
|
+
const rows = [];
|
|
287
|
+
for (let at = 0; at < unique.length; at += 500) {
|
|
288
|
+
rows.push(...await this.db.durableStepCheckpoint.findMany({
|
|
289
|
+
where: {
|
|
290
|
+
runId,
|
|
291
|
+
seq: {
|
|
292
|
+
in: unique.slice(at, at + 500)
|
|
293
|
+
}
|
|
294
|
+
}
|
|
295
|
+
}));
|
|
296
|
+
}
|
|
297
|
+
return rows.sort((a, b) => a.seq - b.seq).map(fromCheckpointRow);
|
|
298
|
+
}
|
|
299
|
+
async getCheckpointsForSettle(runId, seqs) {
|
|
300
|
+
const unique = [
|
|
301
|
+
...new Set(seqs)
|
|
302
|
+
];
|
|
303
|
+
const rows = [];
|
|
304
|
+
for (let at = 0; at < unique.length; at += 500) {
|
|
305
|
+
rows.push(...await this.db.durableStepCheckpoint.findMany({
|
|
306
|
+
where: {
|
|
307
|
+
runId,
|
|
308
|
+
seq: {
|
|
309
|
+
in: unique.slice(at, at + 500)
|
|
310
|
+
}
|
|
311
|
+
},
|
|
312
|
+
select: CHECKPOINT_SELECT_WITHOUT_INPUT
|
|
313
|
+
}));
|
|
314
|
+
}
|
|
315
|
+
return rows.sort((a, b) => a.seq - b.seq).map((row) => fromCheckpointRow({
|
|
316
|
+
...row,
|
|
317
|
+
input: null
|
|
318
|
+
}));
|
|
319
|
+
}
|
|
282
320
|
async saveCheckpoint(checkpoint) {
|
|
283
321
|
const data = toCheckpointData(checkpoint);
|
|
284
322
|
await this.db.durableStepCheckpoint.upsert({
|
|
@@ -307,22 +345,106 @@ var PrismaStateStore = class {
|
|
|
307
345
|
async saveCheckpointsIfPending(checkpoints) {
|
|
308
346
|
if (checkpoints.length === 0) return [];
|
|
309
347
|
return this.db.$transaction(async (tx) => {
|
|
310
|
-
const
|
|
311
|
-
for (const
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
348
|
+
const pending = /* @__PURE__ */ new Set();
|
|
349
|
+
for (const [runId, seqs] of seqsByRun(checkpoints)) {
|
|
350
|
+
for (let at = 0; at < seqs.length; at += 500) {
|
|
351
|
+
const rows = await tx.durableStepCheckpoint.findMany({
|
|
352
|
+
where: {
|
|
353
|
+
runId,
|
|
354
|
+
seq: {
|
|
355
|
+
in: seqs.slice(at, at + 500)
|
|
356
|
+
},
|
|
357
|
+
status: "pending"
|
|
358
|
+
},
|
|
359
|
+
select: {
|
|
360
|
+
runId: true,
|
|
361
|
+
seq: true
|
|
362
|
+
}
|
|
363
|
+
});
|
|
364
|
+
for (const row of rows) pending.add(checkpointKey(row.runId, row.seq));
|
|
365
|
+
}
|
|
366
|
+
}
|
|
367
|
+
const { wrote, writes } = decideIfPending(checkpoints, pending);
|
|
368
|
+
for (const [runId, seqs] of seqsByRun(writes)) {
|
|
369
|
+
for (let at = 0; at < seqs.length; at += 500) {
|
|
370
|
+
const chunk = seqs.slice(at, at + 500);
|
|
371
|
+
const { count } = await tx.durableStepCheckpoint.deleteMany({
|
|
372
|
+
where: {
|
|
373
|
+
runId,
|
|
374
|
+
seq: {
|
|
375
|
+
in: chunk
|
|
376
|
+
},
|
|
377
|
+
status: "pending"
|
|
378
|
+
}
|
|
379
|
+
});
|
|
380
|
+
if (count !== chunk.length) {
|
|
381
|
+
throw new Error("a checkpoint of the batch was settled while the batch was written");
|
|
382
|
+
}
|
|
383
|
+
}
|
|
384
|
+
}
|
|
385
|
+
for (let at = 0; at < writes.length; at += 500) {
|
|
386
|
+
await tx.durableStepCheckpoint.createMany({
|
|
387
|
+
data: writes.slice(at, at + 500).map(toCheckpointData)
|
|
320
388
|
});
|
|
321
|
-
wrote.push(count > 0);
|
|
322
389
|
}
|
|
323
390
|
return wrote;
|
|
324
391
|
});
|
|
325
392
|
}
|
|
393
|
+
async settleCheckpointsIfPending(settlements) {
|
|
394
|
+
const wrote = settlements.map(() => false);
|
|
395
|
+
if (settlements.length === 0) return wrote;
|
|
396
|
+
const seen = /* @__PURE__ */ new Set();
|
|
397
|
+
const firsts = [];
|
|
398
|
+
settlements.forEach((s, i) => {
|
|
399
|
+
const key = checkpointKey(s.runId, s.seq);
|
|
400
|
+
if (seen.has(key)) return;
|
|
401
|
+
seen.add(key);
|
|
402
|
+
firsts.push(i);
|
|
403
|
+
});
|
|
404
|
+
const dialect = rawSettleDialect(this.db);
|
|
405
|
+
if (!dialect) {
|
|
406
|
+
const settle = /* @__PURE__ */ __name(async (db) => {
|
|
407
|
+
for (const i of firsts) {
|
|
408
|
+
const s = settlements[i];
|
|
409
|
+
const { count } = await db.durableStepCheckpoint.updateMany({
|
|
410
|
+
where: {
|
|
411
|
+
runId: s.runId,
|
|
412
|
+
seq: s.seq,
|
|
413
|
+
status: "pending"
|
|
414
|
+
},
|
|
415
|
+
data: {
|
|
416
|
+
status: s.status,
|
|
417
|
+
output: jsonOrNull(s.output),
|
|
418
|
+
error: jsonOrNull(s.error),
|
|
419
|
+
events: jsonOrNull(s.events),
|
|
420
|
+
startedAt: s.startedAt,
|
|
421
|
+
finishedAt: s.finishedAt
|
|
422
|
+
}
|
|
423
|
+
});
|
|
424
|
+
wrote[i] = count > 0;
|
|
425
|
+
}
|
|
426
|
+
}, "settle");
|
|
427
|
+
if (firsts.length === 1) await settle(this.db);
|
|
428
|
+
else await this.db.$transaction((tx) => settle(tx));
|
|
429
|
+
return wrote;
|
|
430
|
+
}
|
|
431
|
+
await this.db.$transaction(async (tx) => {
|
|
432
|
+
const raw = tx;
|
|
433
|
+
for (let at = 0; at < firsts.length; at += 500) {
|
|
434
|
+
const chunk = firsts.slice(at, at + 500);
|
|
435
|
+
const won = await dialect(raw, chunk.map((i) => settlements[i]));
|
|
436
|
+
for (const i of chunk) {
|
|
437
|
+
const s = settlements[i];
|
|
438
|
+
wrote[i] = won.has(checkpointKey(s.runId, s.seq));
|
|
439
|
+
}
|
|
440
|
+
}
|
|
441
|
+
});
|
|
442
|
+
return wrote;
|
|
443
|
+
}
|
|
444
|
+
async saveCheckpoints(checkpoints) {
|
|
445
|
+
if (checkpoints.length === 0) return;
|
|
446
|
+
await this.db.$transaction((tx) => replaceCheckpoints(tx, checkpoints));
|
|
447
|
+
}
|
|
326
448
|
async transaction(work) {
|
|
327
449
|
return this.db.$transaction(async (tx) => work({
|
|
328
450
|
raw: tx,
|
|
@@ -686,6 +808,38 @@ var PrismaStateStore = class {
|
|
|
686
808
|
});
|
|
687
809
|
return rows.map(fromCheckpointRow);
|
|
688
810
|
}
|
|
811
|
+
async listCheckpointsForReplay(runId) {
|
|
812
|
+
const rows = await this.db.durableStepCheckpoint.findMany({
|
|
813
|
+
where: {
|
|
814
|
+
runId
|
|
815
|
+
},
|
|
816
|
+
orderBy: {
|
|
817
|
+
seq: "asc"
|
|
818
|
+
},
|
|
819
|
+
select: CHECKPOINT_SELECT_WITHOUT_INPUT
|
|
820
|
+
});
|
|
821
|
+
const open = rows.filter((row) => row.status !== "completed").map((row) => row.seq);
|
|
822
|
+
const inputs = /* @__PURE__ */ new Map();
|
|
823
|
+
for (let at = 0; at < open.length; at += 500) {
|
|
824
|
+
const found = await this.db.durableStepCheckpoint.findMany({
|
|
825
|
+
where: {
|
|
826
|
+
runId,
|
|
827
|
+
seq: {
|
|
828
|
+
in: open.slice(at, at + 500)
|
|
829
|
+
}
|
|
830
|
+
},
|
|
831
|
+
select: {
|
|
832
|
+
seq: true,
|
|
833
|
+
input: true
|
|
834
|
+
}
|
|
835
|
+
});
|
|
836
|
+
for (const row of found) inputs.set(row.seq, row.input);
|
|
837
|
+
}
|
|
838
|
+
return rows.map((row) => fromCheckpointRow({
|
|
839
|
+
...row,
|
|
840
|
+
input: inputs.get(row.seq) ?? null
|
|
841
|
+
}));
|
|
842
|
+
}
|
|
689
843
|
async getLatestCheckpointByName(runId, name) {
|
|
690
844
|
const row = await this.db.durableStepCheckpoint.findFirst({
|
|
691
845
|
where: {
|
|
@@ -916,36 +1070,25 @@ var PrismaStateStore = class {
|
|
|
916
1070
|
async registerChildWaits(entries) {
|
|
917
1071
|
if (entries.length === 0) return;
|
|
918
1072
|
await this.db.$transaction(async (tx) => {
|
|
919
|
-
for (
|
|
920
|
-
const
|
|
921
|
-
|
|
922
|
-
seq: waiter.seq,
|
|
923
|
-
parallelGroup: waiter.parallelGroup ?? null
|
|
924
|
-
};
|
|
925
|
-
await tx.durableSignalWaiter.upsert({
|
|
1073
|
+
for (let at = 0; at < entries.length; at += 500) {
|
|
1074
|
+
const chunk = entries.slice(at, at + 500);
|
|
1075
|
+
await tx.durableSignalWaiter.deleteMany({
|
|
926
1076
|
where: {
|
|
927
|
-
token:
|
|
928
|
-
|
|
929
|
-
create: {
|
|
930
|
-
token: waiter.token,
|
|
931
|
-
...data
|
|
932
|
-
},
|
|
933
|
-
update: data
|
|
934
|
-
});
|
|
935
|
-
}
|
|
936
|
-
for (const { checkpoint } of entries) {
|
|
937
|
-
const data = toCheckpointData(checkpoint);
|
|
938
|
-
await tx.durableStepCheckpoint.upsert({
|
|
939
|
-
where: {
|
|
940
|
-
runId_seq: {
|
|
941
|
-
runId: checkpoint.runId,
|
|
942
|
-
seq: checkpoint.seq
|
|
1077
|
+
token: {
|
|
1078
|
+
in: chunk.map(({ waiter }) => waiter.token)
|
|
943
1079
|
}
|
|
944
|
-
}
|
|
945
|
-
|
|
946
|
-
|
|
1080
|
+
}
|
|
1081
|
+
});
|
|
1082
|
+
await tx.durableSignalWaiter.createMany({
|
|
1083
|
+
data: chunk.map(({ waiter }) => ({
|
|
1084
|
+
token: waiter.token,
|
|
1085
|
+
runId: waiter.runId,
|
|
1086
|
+
seq: waiter.seq,
|
|
1087
|
+
parallelGroup: waiter.parallelGroup ?? null
|
|
1088
|
+
}))
|
|
947
1089
|
});
|
|
948
1090
|
}
|
|
1091
|
+
await replaceCheckpoints(tx, entries.map(({ checkpoint }) => checkpoint));
|
|
949
1092
|
});
|
|
950
1093
|
}
|
|
951
1094
|
async compactCheckpoints(runId, fromSeq, toSeq, into) {
|
|
@@ -1292,6 +1435,148 @@ function toCheckpointStat(nameKind, r, unenqueued) {
|
|
|
1292
1435
|
};
|
|
1293
1436
|
}
|
|
1294
1437
|
__name(toCheckpointStat, "toCheckpointStat");
|
|
1438
|
+
function seqsByRun(checkpoints) {
|
|
1439
|
+
const byRun = /* @__PURE__ */ new Map();
|
|
1440
|
+
for (const { runId, seq } of checkpoints) {
|
|
1441
|
+
const seqs = byRun.get(runId) ?? /* @__PURE__ */ new Set();
|
|
1442
|
+
seqs.add(seq);
|
|
1443
|
+
byRun.set(runId, seqs);
|
|
1444
|
+
}
|
|
1445
|
+
return new Map([
|
|
1446
|
+
...byRun
|
|
1447
|
+
].map(([runId, seqs]) => [
|
|
1448
|
+
runId,
|
|
1449
|
+
[
|
|
1450
|
+
...seqs
|
|
1451
|
+
]
|
|
1452
|
+
]));
|
|
1453
|
+
}
|
|
1454
|
+
__name(seqsByRun, "seqsByRun");
|
|
1455
|
+
var checkpointKey = /* @__PURE__ */ __name((runId, seq) => `${runId}\0${seq}`, "checkpointKey");
|
|
1456
|
+
function decideIfPending(checkpoints, pending) {
|
|
1457
|
+
const wrote = [];
|
|
1458
|
+
const writes = /* @__PURE__ */ new Map();
|
|
1459
|
+
for (const checkpoint of checkpoints) {
|
|
1460
|
+
const key = checkpointKey(checkpoint.runId, checkpoint.seq);
|
|
1461
|
+
if (!pending.has(key)) {
|
|
1462
|
+
wrote.push(false);
|
|
1463
|
+
continue;
|
|
1464
|
+
}
|
|
1465
|
+
wrote.push(true);
|
|
1466
|
+
writes.set(key, checkpoint);
|
|
1467
|
+
if (checkpoint.status !== "pending") pending.delete(key);
|
|
1468
|
+
}
|
|
1469
|
+
return {
|
|
1470
|
+
wrote,
|
|
1471
|
+
writes: [
|
|
1472
|
+
...writes.values()
|
|
1473
|
+
]
|
|
1474
|
+
};
|
|
1475
|
+
}
|
|
1476
|
+
__name(decideIfPending, "decideIfPending");
|
|
1477
|
+
async function replaceCheckpoints(tx, checkpoints) {
|
|
1478
|
+
for (const [runId, seqs] of seqsByRun(checkpoints)) {
|
|
1479
|
+
for (let at = 0; at < seqs.length; at += 500) {
|
|
1480
|
+
await tx.durableStepCheckpoint.deleteMany({
|
|
1481
|
+
where: {
|
|
1482
|
+
runId,
|
|
1483
|
+
seq: {
|
|
1484
|
+
in: seqs.slice(at, at + 500)
|
|
1485
|
+
}
|
|
1486
|
+
}
|
|
1487
|
+
});
|
|
1488
|
+
}
|
|
1489
|
+
}
|
|
1490
|
+
for (let at = 0; at < checkpoints.length; at += 500) {
|
|
1491
|
+
await tx.durableStepCheckpoint.createMany({
|
|
1492
|
+
data: checkpoints.slice(at, at + 500).map(toCheckpointData)
|
|
1493
|
+
});
|
|
1494
|
+
}
|
|
1495
|
+
}
|
|
1496
|
+
__name(replaceCheckpoints, "replaceCheckpoints");
|
|
1497
|
+
var CHECKPOINT_SELECT_WITHOUT_INPUT = {
|
|
1498
|
+
runId: true,
|
|
1499
|
+
seq: true,
|
|
1500
|
+
name: true,
|
|
1501
|
+
kind: true,
|
|
1502
|
+
stepId: true,
|
|
1503
|
+
status: true,
|
|
1504
|
+
output: true,
|
|
1505
|
+
error: true,
|
|
1506
|
+
events: true,
|
|
1507
|
+
attempts: true,
|
|
1508
|
+
workerGroup: true,
|
|
1509
|
+
parallelGroup: true,
|
|
1510
|
+
wakeAt: true,
|
|
1511
|
+
enqueuedAt: true,
|
|
1512
|
+
startedAt: true,
|
|
1513
|
+
finishedAt: true
|
|
1514
|
+
};
|
|
1515
|
+
var jsonText = /* @__PURE__ */ __name((v) => v == null ? null : JSON.stringify(v), "jsonText");
|
|
1516
|
+
function rawSettleDialect(db) {
|
|
1517
|
+
const client = db;
|
|
1518
|
+
if (typeof client.$queryRawUnsafe !== "function") return void 0;
|
|
1519
|
+
if (client._activeProvider === "postgresql") return settleRowsPostgres;
|
|
1520
|
+
if (client._activeProvider === "mysql") return settleRowsMysql;
|
|
1521
|
+
if (client._activeProvider === "sqlite") return settleRowsSqlite;
|
|
1522
|
+
return void 0;
|
|
1523
|
+
}
|
|
1524
|
+
__name(rawSettleDialect, "rawSettleDialect");
|
|
1525
|
+
var settleRowsPostgres = /* @__PURE__ */ __name(async (db, settlements) => {
|
|
1526
|
+
const values = [];
|
|
1527
|
+
const rows = settlements.map((s) => {
|
|
1528
|
+
const n = values.length;
|
|
1529
|
+
values.push(s.runId, s.seq, s.status, jsonText(s.output), jsonText(s.error), jsonText(s.events), s.startedAt.toISOString(), s.finishedAt.toISOString());
|
|
1530
|
+
const p = /* @__PURE__ */ __name((k) => `$${n + k}`, "p");
|
|
1531
|
+
return `(${p(1)}::text, ${p(2)}::integer, ${p(3)}::text, ${p(4)}::jsonb, ${p(5)}::jsonb, ${p(6)}::jsonb, (${p(7)}::timestamptz AT TIME ZONE 'UTC'), (${p(8)}::timestamptz AT TIME ZONE 'UTC'))`;
|
|
1532
|
+
});
|
|
1533
|
+
const written = await db.$queryRawUnsafe(`UPDATE "durable_step_checkpoints" AS c SET status = v.status, output = v.output,
|
|
1534
|
+
error = v.error, events = v.events, started_at = v.started_at, finished_at = v.finished_at
|
|
1535
|
+
FROM (VALUES ${rows.join(", ")}) AS v(run_id, seq, status, output, error, events, started_at,
|
|
1536
|
+
finished_at)
|
|
1537
|
+
WHERE c.run_id = v.run_id AND c.seq = v.seq AND c.status = 'pending'
|
|
1538
|
+
RETURNING c.run_id, c.seq`, ...values);
|
|
1539
|
+
return new Set(written.map((row) => checkpointKey(row.run_id, Number(row.seq))));
|
|
1540
|
+
}, "settleRowsPostgres");
|
|
1541
|
+
var settleRowsMysql = /* @__PURE__ */ __name(async (db, settlements) => {
|
|
1542
|
+
const pending = /* @__PURE__ */ new Set();
|
|
1543
|
+
for (const [runId, seqs] of seqsByRun(settlements)) {
|
|
1544
|
+
const rows2 = await db.$queryRawUnsafe(`SELECT run_id, seq FROM durable_step_checkpoints WHERE run_id = ? AND seq IN (${seqs.map(() => "?").join(", ")}) AND status = 'pending' FOR UPDATE`, runId, ...seqs);
|
|
1545
|
+
for (const row of rows2) pending.add(checkpointKey(row.run_id, Number(row.seq)));
|
|
1546
|
+
}
|
|
1547
|
+
const won = settlements.filter((s) => pending.has(checkpointKey(s.runId, s.seq)));
|
|
1548
|
+
if (won.length === 0) return pending;
|
|
1549
|
+
const at = /* @__PURE__ */ __name((d) => d.toISOString().replace("T", " ").replace("Z", ""), "at");
|
|
1550
|
+
const values = [];
|
|
1551
|
+
const rows = won.map((s, i) => {
|
|
1552
|
+
values.push(s.runId, s.seq, s.status, jsonText(s.output), jsonText(s.error), jsonText(s.events), at(s.startedAt), at(s.finishedAt));
|
|
1553
|
+
return i === 0 ? "SELECT ? AS run_id, ? AS seq, ? AS status, ? AS output, ? AS error, ? AS events, ? AS started_at, ? AS finished_at" : "SELECT ?, ?, ?, ?, ?, ?, ?, ?";
|
|
1554
|
+
});
|
|
1555
|
+
const updated = await db.$executeRawUnsafe(`UPDATE durable_step_checkpoints AS c JOIN (${rows.join(" UNION ALL ")}) AS v
|
|
1556
|
+
ON c.run_id = v.run_id AND c.seq = v.seq
|
|
1557
|
+
SET c.status = v.status, c.output = CAST(v.output AS JSON), c.error = CAST(v.error AS JSON),
|
|
1558
|
+
c.events = CAST(v.events AS JSON), c.started_at = v.started_at, c.finished_at = v.finished_at
|
|
1559
|
+
WHERE c.status = 'pending'`, ...values);
|
|
1560
|
+
if (updated !== won.length) {
|
|
1561
|
+
throw new Error("a checkpoint of the batch was settled while the batch was written");
|
|
1562
|
+
}
|
|
1563
|
+
return pending;
|
|
1564
|
+
}, "settleRowsMysql");
|
|
1565
|
+
var settleRowsSqlite = /* @__PURE__ */ __name(async (db, settlements) => {
|
|
1566
|
+
const values = [];
|
|
1567
|
+
const rows = settlements.map((s) => {
|
|
1568
|
+
values.push(s.runId, s.seq, s.status, jsonText(s.output), jsonText(s.error), jsonText(s.events), s.startedAt.getTime(), s.finishedAt.getTime());
|
|
1569
|
+
return "(?, ?, ?, ?, ?, ?, ?, ?)";
|
|
1570
|
+
});
|
|
1571
|
+
const written = await db.$queryRawUnsafe(`WITH v(run_id, seq, status, output, error, events, started_at, finished_at) AS (VALUES ${rows.join(", ")})
|
|
1572
|
+
UPDATE durable_step_checkpoints SET status = v.status, output = v.output, error = v.error,
|
|
1573
|
+
events = v.events, started_at = v.started_at, finished_at = v.finished_at
|
|
1574
|
+
FROM v
|
|
1575
|
+
WHERE durable_step_checkpoints.run_id = v.run_id AND durable_step_checkpoints.seq = v.seq
|
|
1576
|
+
AND durable_step_checkpoints.status = 'pending'
|
|
1577
|
+
RETURNING run_id, seq`, ...values);
|
|
1578
|
+
return new Set(written.map((row) => checkpointKey(row.run_id, Number(row.seq))));
|
|
1579
|
+
}, "settleRowsSqlite");
|
|
1295
1580
|
function toCheckpointData(cp) {
|
|
1296
1581
|
return {
|
|
1297
1582
|
runId: cp.runId,
|