@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 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 wrote = [];
311
- for (const checkpoint of checkpoints) {
312
- const { runId, seq, ...data } = toCheckpointData(checkpoint);
313
- const { count } = await tx.durableStepCheckpoint.updateMany({
314
- where: {
315
- runId,
316
- seq,
317
- status: "pending"
318
- },
319
- data
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 (const { waiter } of entries) {
920
- const data = {
921
- runId: waiter.runId,
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: waiter.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
- create: data,
946
- update: data
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,