@dudousxd/nestjs-durable-store-prisma 0.24.3 → 0.24.5
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 +209 -0
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +5 -1
- package/dist/index.d.ts +5 -1
- package/dist/index.js +209 -0
- package/dist/index.js.map +1 -1
- package/package.json +3 -3
package/dist/index.cjs
CHANGED
|
@@ -296,6 +296,27 @@ var PrismaStateStore = class {
|
|
|
296
296
|
}
|
|
297
297
|
return rows.sort((a, b) => a.seq - b.seq).map(fromCheckpointRow);
|
|
298
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
|
+
}
|
|
299
320
|
async saveCheckpoint(checkpoint) {
|
|
300
321
|
const data = toCheckpointData(checkpoint);
|
|
301
322
|
await this.db.durableStepCheckpoint.upsert({
|
|
@@ -369,6 +390,57 @@ var PrismaStateStore = class {
|
|
|
369
390
|
return wrote;
|
|
370
391
|
});
|
|
371
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
|
+
}
|
|
372
444
|
async saveCheckpoints(checkpoints) {
|
|
373
445
|
if (checkpoints.length === 0) return;
|
|
374
446
|
await this.db.$transaction((tx) => replaceCheckpoints(tx, checkpoints));
|
|
@@ -736,6 +808,38 @@ var PrismaStateStore = class {
|
|
|
736
808
|
});
|
|
737
809
|
return rows.map(fromCheckpointRow);
|
|
738
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
|
+
}
|
|
739
843
|
async getLatestCheckpointByName(runId, name) {
|
|
740
844
|
const row = await this.db.durableStepCheckpoint.findFirst({
|
|
741
845
|
where: {
|
|
@@ -748,6 +852,28 @@ var PrismaStateStore = class {
|
|
|
748
852
|
});
|
|
749
853
|
return row ? fromCheckpointRow(row) : void 0;
|
|
750
854
|
}
|
|
855
|
+
async hasCheckpoints(runId, fromSeq, toSeq, statuses) {
|
|
856
|
+
if (statuses.length === 0) return false;
|
|
857
|
+
const row = await this.db.durableStepCheckpoint.findFirst({
|
|
858
|
+
where: {
|
|
859
|
+
runId,
|
|
860
|
+
seq: {
|
|
861
|
+
gte: fromSeq,
|
|
862
|
+
lte: toSeq
|
|
863
|
+
},
|
|
864
|
+
status: {
|
|
865
|
+
in: statuses
|
|
866
|
+
}
|
|
867
|
+
},
|
|
868
|
+
select: {
|
|
869
|
+
seq: true
|
|
870
|
+
},
|
|
871
|
+
orderBy: {
|
|
872
|
+
seq: "desc"
|
|
873
|
+
}
|
|
874
|
+
});
|
|
875
|
+
return row !== null;
|
|
876
|
+
}
|
|
751
877
|
async countCheckpoints(runId, fromSeq, toSeq, statuses) {
|
|
752
878
|
if (statuses.length === 0) return 0;
|
|
753
879
|
return this.db.durableStepCheckpoint.count({
|
|
@@ -1390,6 +1516,89 @@ async function replaceCheckpoints(tx, checkpoints) {
|
|
|
1390
1516
|
}
|
|
1391
1517
|
}
|
|
1392
1518
|
__name(replaceCheckpoints, "replaceCheckpoints");
|
|
1519
|
+
var CHECKPOINT_SELECT_WITHOUT_INPUT = {
|
|
1520
|
+
runId: true,
|
|
1521
|
+
seq: true,
|
|
1522
|
+
name: true,
|
|
1523
|
+
kind: true,
|
|
1524
|
+
stepId: true,
|
|
1525
|
+
status: true,
|
|
1526
|
+
output: true,
|
|
1527
|
+
error: true,
|
|
1528
|
+
events: true,
|
|
1529
|
+
attempts: true,
|
|
1530
|
+
workerGroup: true,
|
|
1531
|
+
parallelGroup: true,
|
|
1532
|
+
wakeAt: true,
|
|
1533
|
+
enqueuedAt: true,
|
|
1534
|
+
startedAt: true,
|
|
1535
|
+
finishedAt: true
|
|
1536
|
+
};
|
|
1537
|
+
var jsonText = /* @__PURE__ */ __name((v) => v == null ? null : JSON.stringify(v), "jsonText");
|
|
1538
|
+
function rawSettleDialect(db) {
|
|
1539
|
+
const client = db;
|
|
1540
|
+
if (typeof client.$queryRawUnsafe !== "function") return void 0;
|
|
1541
|
+
if (client._activeProvider === "postgresql") return settleRowsPostgres;
|
|
1542
|
+
if (client._activeProvider === "mysql") return settleRowsMysql;
|
|
1543
|
+
if (client._activeProvider === "sqlite") return settleRowsSqlite;
|
|
1544
|
+
return void 0;
|
|
1545
|
+
}
|
|
1546
|
+
__name(rawSettleDialect, "rawSettleDialect");
|
|
1547
|
+
var settleRowsPostgres = /* @__PURE__ */ __name(async (db, settlements) => {
|
|
1548
|
+
const values = [];
|
|
1549
|
+
const rows = settlements.map((s) => {
|
|
1550
|
+
const n = values.length;
|
|
1551
|
+
values.push(s.runId, s.seq, s.status, jsonText(s.output), jsonText(s.error), jsonText(s.events), s.startedAt.toISOString(), s.finishedAt.toISOString());
|
|
1552
|
+
const p = /* @__PURE__ */ __name((k) => `$${n + k}`, "p");
|
|
1553
|
+
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'))`;
|
|
1554
|
+
});
|
|
1555
|
+
const written = await db.$queryRawUnsafe(`UPDATE "durable_step_checkpoints" AS c SET status = v.status, output = v.output,
|
|
1556
|
+
error = v.error, events = v.events, started_at = v.started_at, finished_at = v.finished_at
|
|
1557
|
+
FROM (VALUES ${rows.join(", ")}) AS v(run_id, seq, status, output, error, events, started_at,
|
|
1558
|
+
finished_at)
|
|
1559
|
+
WHERE c.run_id = v.run_id AND c.seq = v.seq AND c.status = 'pending'
|
|
1560
|
+
RETURNING c.run_id, c.seq`, ...values);
|
|
1561
|
+
return new Set(written.map((row) => checkpointKey(row.run_id, Number(row.seq))));
|
|
1562
|
+
}, "settleRowsPostgres");
|
|
1563
|
+
var settleRowsMysql = /* @__PURE__ */ __name(async (db, settlements) => {
|
|
1564
|
+
const pending = /* @__PURE__ */ new Set();
|
|
1565
|
+
for (const [runId, seqs] of seqsByRun(settlements)) {
|
|
1566
|
+
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);
|
|
1567
|
+
for (const row of rows2) pending.add(checkpointKey(row.run_id, Number(row.seq)));
|
|
1568
|
+
}
|
|
1569
|
+
const won = settlements.filter((s) => pending.has(checkpointKey(s.runId, s.seq)));
|
|
1570
|
+
if (won.length === 0) return pending;
|
|
1571
|
+
const at = /* @__PURE__ */ __name((d) => d.toISOString().replace("T", " ").replace("Z", ""), "at");
|
|
1572
|
+
const values = [];
|
|
1573
|
+
const rows = won.map((s, i) => {
|
|
1574
|
+
values.push(s.runId, s.seq, s.status, jsonText(s.output), jsonText(s.error), jsonText(s.events), at(s.startedAt), at(s.finishedAt));
|
|
1575
|
+
return i === 0 ? "SELECT ? AS run_id, ? AS seq, ? AS status, ? AS output, ? AS error, ? AS events, ? AS started_at, ? AS finished_at" : "SELECT ?, ?, ?, ?, ?, ?, ?, ?";
|
|
1576
|
+
});
|
|
1577
|
+
const updated = await db.$executeRawUnsafe(`UPDATE durable_step_checkpoints AS c JOIN (${rows.join(" UNION ALL ")}) AS v
|
|
1578
|
+
ON c.run_id = v.run_id AND c.seq = v.seq
|
|
1579
|
+
SET c.status = v.status, c.output = CAST(v.output AS JSON), c.error = CAST(v.error AS JSON),
|
|
1580
|
+
c.events = CAST(v.events AS JSON), c.started_at = v.started_at, c.finished_at = v.finished_at
|
|
1581
|
+
WHERE c.status = 'pending'`, ...values);
|
|
1582
|
+
if (updated !== won.length) {
|
|
1583
|
+
throw new Error("a checkpoint of the batch was settled while the batch was written");
|
|
1584
|
+
}
|
|
1585
|
+
return pending;
|
|
1586
|
+
}, "settleRowsMysql");
|
|
1587
|
+
var settleRowsSqlite = /* @__PURE__ */ __name(async (db, settlements) => {
|
|
1588
|
+
const values = [];
|
|
1589
|
+
const rows = settlements.map((s) => {
|
|
1590
|
+
values.push(s.runId, s.seq, s.status, jsonText(s.output), jsonText(s.error), jsonText(s.events), s.startedAt.getTime(), s.finishedAt.getTime());
|
|
1591
|
+
return "(?, ?, ?, ?, ?, ?, ?, ?)";
|
|
1592
|
+
});
|
|
1593
|
+
const written = await db.$queryRawUnsafe(`WITH v(run_id, seq, status, output, error, events, started_at, finished_at) AS (VALUES ${rows.join(", ")})
|
|
1594
|
+
UPDATE durable_step_checkpoints SET status = v.status, output = v.output, error = v.error,
|
|
1595
|
+
events = v.events, started_at = v.started_at, finished_at = v.finished_at
|
|
1596
|
+
FROM v
|
|
1597
|
+
WHERE durable_step_checkpoints.run_id = v.run_id AND durable_step_checkpoints.seq = v.seq
|
|
1598
|
+
AND durable_step_checkpoints.status = 'pending'
|
|
1599
|
+
RETURNING run_id, seq`, ...values);
|
|
1600
|
+
return new Set(written.map((row) => checkpointKey(row.run_id, Number(row.seq))));
|
|
1601
|
+
}, "settleRowsSqlite");
|
|
1393
1602
|
function toCheckpointData(cp) {
|
|
1394
1603
|
return {
|
|
1395
1604
|
runId: cp.runId,
|