@dudousxd/nestjs-durable-store-drizzle 0.25.0 → 0.26.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 +62 -0
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +148 -1
- package/dist/index.d.ts +148 -1
- package/dist/index.js +61 -0
- package/dist/index.js.map +1 -1
- package/dist/pg/index.cjs +708 -118
- package/dist/pg/index.cjs.map +1 -1
- package/dist/pg/index.d.cts +159 -2
- package/dist/pg/index.d.ts +159 -2
- package/dist/pg/index.js +586 -7
- package/dist/pg/index.js.map +1 -1
- package/package.json +3 -3
package/dist/pg/index.js
CHANGED
|
@@ -102,6 +102,12 @@ var DURABLE_PG_DDL = [
|
|
|
102
102
|
"name" text NOT NULL,
|
|
103
103
|
"payload" jsonb,
|
|
104
104
|
"published_at" timestamp with time zone NOT NULL
|
|
105
|
+
)`,
|
|
106
|
+
`CREATE TABLE IF NOT EXISTS "durable_signal_ids" (
|
|
107
|
+
"token" text NOT NULL,
|
|
108
|
+
"signal_id" text NOT NULL,
|
|
109
|
+
"expires_at" timestamp with time zone NOT NULL,
|
|
110
|
+
CONSTRAINT "durable_signal_ids_token_signal_id_pk" PRIMARY KEY("token","signal_id")
|
|
105
111
|
)`,
|
|
106
112
|
`CREATE TABLE IF NOT EXISTS "durable_schedules" (
|
|
107
113
|
"id" text PRIMARY KEY NOT NULL,
|
|
@@ -126,7 +132,8 @@ var DURABLE_PG_DDL = [
|
|
|
126
132
|
`CREATE INDEX IF NOT EXISTS "durable_signal_waiters_run_id_idx" ON "durable_signal_waiters" USING btree ("run_id")`,
|
|
127
133
|
`CREATE INDEX IF NOT EXISTS "durable_buffered_signals_token_idx" ON "durable_buffered_signals" USING btree ("token","id")`,
|
|
128
134
|
`CREATE INDEX IF NOT EXISTS "durable_buffered_events_name_published_at_idx" ON "durable_buffered_events" USING btree ("name","published_at")`,
|
|
129
|
-
`CREATE INDEX IF NOT EXISTS "durable_schedules_due_idx" ON "durable_schedules" USING btree ("paused","next_fire_at")
|
|
135
|
+
`CREATE INDEX IF NOT EXISTS "durable_schedules_due_idx" ON "durable_schedules" USING btree ("paused","next_fire_at")`,
|
|
136
|
+
`CREATE INDEX IF NOT EXISTS "durable_signal_ids_expires_at_idx" ON "durable_signal_ids" USING btree ("expires_at")`
|
|
130
137
|
];
|
|
131
138
|
var SCHEMA_LOCK_KEY = "durable_schema";
|
|
132
139
|
function drizzlePgSchemaRepairWarning(repairs) {
|
|
@@ -199,7 +206,119 @@ __name(ensureDrizzlePgDurableSchema, "ensureDrizzlePgDurableSchema");
|
|
|
199
206
|
|
|
200
207
|
// src/pg/drizzle-pg-state-store.ts
|
|
201
208
|
import { LIFECYCLE_REGISTRY_WORKFLOW, RUN_VALUE_FACET_SCAN, SINGLETON_ACTIVE_STATUSES, TERMINAL_RUN_STATUSES, attributePredicateOperands, axisIsRunColumn, clearTerminalSingletonAdmission, mergeRunFacetRows, mergeRunValueFacetRows, normalizeAttributeRows, parseDuration, retentionKeeps, runValueFacetsFromRuns, singletonAdmissionDenialPatch, singletonAdmissionTags } from "@dudousxd/nestjs-durable-core";
|
|
202
|
-
import { and, asc, desc, eq, exists, getTableColumns, gt, gte, inArray, isNotNull, isNull, like, lt, lte, notInArray, or, sql as sql3 } from "drizzle-orm";
|
|
209
|
+
import { and, asc, desc, eq, exists, getTableColumns as getTableColumns2, getTableName as getTableName2, gt, gte, inArray, isNotNull, isNull, like, lt, lte, notInArray, or, sql as sql3 } from "drizzle-orm";
|
|
210
|
+
|
|
211
|
+
// src/pg/hot-path.ts
|
|
212
|
+
import * as drizzleOrm from "drizzle-orm";
|
|
213
|
+
import { getTableColumns } from "drizzle-orm";
|
|
214
|
+
function nodePgClient(db) {
|
|
215
|
+
const client = db.$client;
|
|
216
|
+
if (!client || typeof client !== "object") return void 0;
|
|
217
|
+
if (typeof client.query !== "function") return void 0;
|
|
218
|
+
const isPool = "totalCount" in client && "idleCount" in client;
|
|
219
|
+
const isClient = "connectionParameters" in client;
|
|
220
|
+
return isPool || isClient ? client : void 0;
|
|
221
|
+
}
|
|
222
|
+
__name(nodePgClient, "nodePgClient");
|
|
223
|
+
function drizzleLogger(db) {
|
|
224
|
+
const logger = db.session?.logger;
|
|
225
|
+
if (!logger || typeof logger.logQuery !== "function") return void 0;
|
|
226
|
+
if (logger.constructor?.name === "NoopLogger") {
|
|
227
|
+
return void 0;
|
|
228
|
+
}
|
|
229
|
+
return logger;
|
|
230
|
+
}
|
|
231
|
+
__name(drizzleLogger, "drizzleLogger");
|
|
232
|
+
var QueryError = drizzleOrm.DrizzleQueryError;
|
|
233
|
+
function hash(text2) {
|
|
234
|
+
let h = 2166136261;
|
|
235
|
+
for (let i = 0; i < text2.length; i += 1) {
|
|
236
|
+
h ^= text2.charCodeAt(i);
|
|
237
|
+
h = Math.imul(h, 16777619);
|
|
238
|
+
}
|
|
239
|
+
return (h >>> 0).toString(36);
|
|
240
|
+
}
|
|
241
|
+
__name(hash, "hash");
|
|
242
|
+
var PgHotPath = class _PgHotPath {
|
|
243
|
+
static {
|
|
244
|
+
__name(this, "PgHotPath");
|
|
245
|
+
}
|
|
246
|
+
client;
|
|
247
|
+
logger;
|
|
248
|
+
prepared;
|
|
249
|
+
constructor(client, logger, prepared) {
|
|
250
|
+
this.client = client;
|
|
251
|
+
this.logger = logger;
|
|
252
|
+
this.prepared = prepared;
|
|
253
|
+
}
|
|
254
|
+
/** The hot path for `db`, or `undefined` when `db` does not run on node-postgres. */
|
|
255
|
+
static for(db, options = {}) {
|
|
256
|
+
const client = nodePgClient(db);
|
|
257
|
+
if (!client) return void 0;
|
|
258
|
+
return new _PgHotPath(client, drizzleLogger(db), options.preparedStatements !== false);
|
|
259
|
+
}
|
|
260
|
+
/** Run one statement; resolves its rows as the driver decoded them (column names as stored). */
|
|
261
|
+
async query(text2, values) {
|
|
262
|
+
this.logger?.logQuery(text2, values);
|
|
263
|
+
const config = {
|
|
264
|
+
text: text2,
|
|
265
|
+
values
|
|
266
|
+
};
|
|
267
|
+
if (this.prepared) config.name = `durable_${hash(text2)}`;
|
|
268
|
+
try {
|
|
269
|
+
return (await this.client.query(config)).rows;
|
|
270
|
+
} catch (err) {
|
|
271
|
+
throw QueryError ? new QueryError(text2, values, err) : err;
|
|
272
|
+
}
|
|
273
|
+
}
|
|
274
|
+
};
|
|
275
|
+
var TableCodec = class {
|
|
276
|
+
static {
|
|
277
|
+
__name(this, "TableCodec");
|
|
278
|
+
}
|
|
279
|
+
columns;
|
|
280
|
+
/** `"a", "b", …` in column order. */
|
|
281
|
+
list;
|
|
282
|
+
constructor(table, omit = []) {
|
|
283
|
+
this.columns = Object.entries(getTableColumns(table)).filter(([key]) => !omit.includes(key));
|
|
284
|
+
this.list = this.columns.map(([, c]) => quote(c.name)).join(", ");
|
|
285
|
+
}
|
|
286
|
+
/** The quoted column name of `property`. */
|
|
287
|
+
name(property) {
|
|
288
|
+
const found = this.columns.find(([key]) => key === property);
|
|
289
|
+
if (!found) throw new Error(`no column for ${property}`);
|
|
290
|
+
return quote(found[1].name);
|
|
291
|
+
}
|
|
292
|
+
/** A value of `property` as drizzle's builder would bind it. */
|
|
293
|
+
encode(property, value) {
|
|
294
|
+
if (value == null) return null;
|
|
295
|
+
const found = this.columns.find(([key]) => key === property);
|
|
296
|
+
return found ? found[1].mapToDriverValue(value) : value;
|
|
297
|
+
}
|
|
298
|
+
/** A row's values, in column order, as drizzle's builder would bind them. */
|
|
299
|
+
encodeRow(row) {
|
|
300
|
+
return this.columns.map(([key, column]) => {
|
|
301
|
+
const value = row[key];
|
|
302
|
+
return value == null ? null : column.mapToDriverValue(value);
|
|
303
|
+
});
|
|
304
|
+
}
|
|
305
|
+
/** A row a statement returned, as drizzle would map it (absent / omitted columns read `null`). */
|
|
306
|
+
decode(raw) {
|
|
307
|
+
const row = {};
|
|
308
|
+
for (const [key, column] of this.columns) {
|
|
309
|
+
const value = raw[column.name];
|
|
310
|
+
row[key] = value == null ? null : column.mapFromDriverValue(value);
|
|
311
|
+
}
|
|
312
|
+
return row;
|
|
313
|
+
}
|
|
314
|
+
};
|
|
315
|
+
var quote = /* @__PURE__ */ __name((name) => `"${name.replace(/"/g, '""')}"`, "quote");
|
|
316
|
+
function placeholders(from, count) {
|
|
317
|
+
return Array.from({
|
|
318
|
+
length: count
|
|
319
|
+
}, (_, i) => `$${from + i}`).join(", ");
|
|
320
|
+
}
|
|
321
|
+
__name(placeholders, "placeholders");
|
|
203
322
|
|
|
204
323
|
// src/pg/schema.ts
|
|
205
324
|
import { getTableName } from "drizzle-orm";
|
|
@@ -332,6 +451,19 @@ var durableBufferedEvents = pgTable("durable_buffered_events", {
|
|
|
332
451
|
}, (t) => [
|
|
333
452
|
index("durable_buffered_events_name_published_at_idx").on(t.name, t.publishedAt)
|
|
334
453
|
]);
|
|
454
|
+
var durableSignalIds = pgTable("durable_signal_ids", {
|
|
455
|
+
token: text("token").notNull(),
|
|
456
|
+
signalId: text("signal_id").notNull(),
|
|
457
|
+
expiresAt: tstz("expires_at").notNull()
|
|
458
|
+
}, (t) => [
|
|
459
|
+
primaryKey({
|
|
460
|
+
columns: [
|
|
461
|
+
t.token,
|
|
462
|
+
t.signalId
|
|
463
|
+
]
|
|
464
|
+
}),
|
|
465
|
+
index("durable_signal_ids_expires_at_idx").on(t.expiresAt)
|
|
466
|
+
]);
|
|
335
467
|
var durableSchedules = pgTable(
|
|
336
468
|
"durable_schedules",
|
|
337
469
|
{
|
|
@@ -358,6 +490,7 @@ var durablePgSchema = {
|
|
|
358
490
|
durableSignalWaiters,
|
|
359
491
|
durableBufferedSignals,
|
|
360
492
|
durableBufferedEvents,
|
|
493
|
+
durableSignalIds,
|
|
361
494
|
durableSchedules
|
|
362
495
|
};
|
|
363
496
|
function durablePgManagedTables() {
|
|
@@ -400,10 +533,59 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
400
533
|
db;
|
|
401
534
|
options;
|
|
402
535
|
scopeNamespace;
|
|
536
|
+
/** Constant-SQL path for the per-step statements, on node-postgres (see `hot-path.ts`). */
|
|
537
|
+
hot;
|
|
538
|
+
/** The run read-scope predicate as SQL text from `$2` on, and its values (hot path). */
|
|
539
|
+
hotScope;
|
|
540
|
+
/** Hot-path UPDATE texts by patch shape. */
|
|
541
|
+
hotUpdates = /* @__PURE__ */ new Map();
|
|
403
542
|
constructor(db, options = {}) {
|
|
404
543
|
this.db = db;
|
|
405
544
|
this.options = options;
|
|
406
545
|
this.scopeNamespace = options.scope?.namespace;
|
|
546
|
+
this.hot = PgHotPath.for(db, {
|
|
547
|
+
preparedStatements: options.preparedStatements
|
|
548
|
+
});
|
|
549
|
+
const ns = this.scopeNamespace;
|
|
550
|
+
this.hotScope = ns === void 0 ? {
|
|
551
|
+
text: "",
|
|
552
|
+
values: []
|
|
553
|
+
} : ns === DEFAULT_NAMESPACE || ns === "" ? {
|
|
554
|
+
text: ' AND "namespace" IN ($2, $3)',
|
|
555
|
+
values: [
|
|
556
|
+
DEFAULT_NAMESPACE,
|
|
557
|
+
""
|
|
558
|
+
]
|
|
559
|
+
} : {
|
|
560
|
+
text: ' AND "namespace" = $2',
|
|
561
|
+
values: [
|
|
562
|
+
ns
|
|
563
|
+
]
|
|
564
|
+
};
|
|
565
|
+
}
|
|
566
|
+
/**
|
|
567
|
+
* A hot-path `UPDATE` of the runs table setting `row`'s columns on run `$n`, optionally only while
|
|
568
|
+
* its status is one of `expected` (then `RETURNING "id"`). Text cached per shape.
|
|
569
|
+
*/
|
|
570
|
+
hotRunUpdate(runId, row, expected) {
|
|
571
|
+
const keys = Object.keys(row);
|
|
572
|
+
const shape = `${keys.join(",")}|${expected?.length ?? -1}`;
|
|
573
|
+
let text2 = this.hotUpdates.get(shape);
|
|
574
|
+
if (text2 === void 0) {
|
|
575
|
+
const set = keys.map((key, i) => `${RUNS.name(key)} = $${i + 1}`).join(", ");
|
|
576
|
+
const id = keys.length + 1;
|
|
577
|
+
text2 = `UPDATE ${T_RUNS} SET ${set} WHERE "id" = $${id}`;
|
|
578
|
+
if (expected) {
|
|
579
|
+
text2 += ` AND "status" IN (${placeholders(id + 1, expected.length)}) RETURNING "id"`;
|
|
580
|
+
}
|
|
581
|
+
this.hotUpdates.set(shape, text2);
|
|
582
|
+
}
|
|
583
|
+
const values = keys.map((key) => RUNS.encode(key, row[key]));
|
|
584
|
+
values.push(runId, ...expected ?? []);
|
|
585
|
+
return {
|
|
586
|
+
text: text2,
|
|
587
|
+
values
|
|
588
|
+
};
|
|
407
589
|
}
|
|
408
590
|
/** A store confined to `scope.namespace`, sharing this store's db (no new connection). Used by the
|
|
409
591
|
* NestJS module's `scopeReads`; `{ namespace: undefined }` is the unscoped operator view. */
|
|
@@ -446,6 +628,13 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
446
628
|
}
|
|
447
629
|
async createRun(run) {
|
|
448
630
|
if (normalizeAttributeRows(run.id, run.searchAttributes).length === 0) {
|
|
631
|
+
if (this.hot) {
|
|
632
|
+
await this.hot.query(INSERT_RUN, RUNS.encodeRow(toRunRow(run)));
|
|
633
|
+
await this.hot.query(DELETE_ATTRIBUTES, [
|
|
634
|
+
run.id
|
|
635
|
+
]);
|
|
636
|
+
return;
|
|
637
|
+
}
|
|
449
638
|
await this.db.insert(durableWorkflowRuns).values(toRunRow(run));
|
|
450
639
|
await this.db.delete(durableRunAttributes).where(eq(durableRunAttributes.runId, run.id));
|
|
451
640
|
return;
|
|
@@ -461,6 +650,11 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
461
650
|
const reindex = "searchAttributes" in patch;
|
|
462
651
|
if (!Object.keys(row).length && !reindex) return;
|
|
463
652
|
if (!reindex) {
|
|
653
|
+
if (this.hot) {
|
|
654
|
+
const { text: text2, values } = this.hotRunUpdate(runId, row);
|
|
655
|
+
await this.hot.query(text2, values);
|
|
656
|
+
return;
|
|
657
|
+
}
|
|
464
658
|
await this.db.update(durableWorkflowRuns).set(row).where(eq(durableWorkflowRuns.id, runId));
|
|
465
659
|
return;
|
|
466
660
|
}
|
|
@@ -475,6 +669,16 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
475
669
|
const row = toRunPatch(patch);
|
|
476
670
|
const reindex = "searchAttributes" in patch;
|
|
477
671
|
const matches = and(eq(durableWorkflowRuns.id, runId), inArray(durableWorkflowRuns.status, expectedStatuses));
|
|
672
|
+
if (!reindex && Object.keys(row).length) {
|
|
673
|
+
if (this.hot) {
|
|
674
|
+
const { text: text2, values } = this.hotRunUpdate(runId, row, expectedStatuses);
|
|
675
|
+
return (await this.hot.query(text2, values)).length === 1;
|
|
676
|
+
}
|
|
677
|
+
const applied = await this.db.update(durableWorkflowRuns).set(row).where(matches).returning({
|
|
678
|
+
id: durableWorkflowRuns.id
|
|
679
|
+
});
|
|
680
|
+
return applied.length === 1;
|
|
681
|
+
}
|
|
478
682
|
return this.db.transaction(async (tx) => {
|
|
479
683
|
const applied = Object.keys(row).length ? (await tx.update(durableWorkflowRuns).set(row).where(matches).returning({
|
|
480
684
|
id: durableWorkflowRuns.id
|
|
@@ -486,6 +690,13 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
486
690
|
});
|
|
487
691
|
}
|
|
488
692
|
async getRun(runId) {
|
|
693
|
+
if (this.hot) {
|
|
694
|
+
const rows2 = await this.hot.query(`${SELECT_RUN}${this.hotScope.text} LIMIT 1`, [
|
|
695
|
+
runId,
|
|
696
|
+
...this.hotScope.values
|
|
697
|
+
]);
|
|
698
|
+
return rows2[0] ? fromRunRow(RUNS.decode(rows2[0])) : null;
|
|
699
|
+
}
|
|
489
700
|
const rows = await this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.id, runId), this.scope())).limit(1);
|
|
490
701
|
return rows[0] ? fromRunRow(rows[0]) : null;
|
|
491
702
|
}
|
|
@@ -551,6 +762,13 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
551
762
|
});
|
|
552
763
|
}
|
|
553
764
|
async getCheckpoint(runId, seq) {
|
|
765
|
+
if (this.hot) {
|
|
766
|
+
const rows2 = await this.hot.query(SELECT_CHECKPOINT, [
|
|
767
|
+
runId,
|
|
768
|
+
seq
|
|
769
|
+
]);
|
|
770
|
+
return rows2[0] ? fromCheckpointRow(CPS.decode(rows2[0])) : null;
|
|
771
|
+
}
|
|
554
772
|
const rows = await this.db.select().from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), eq(durableStepCheckpoints.seq, seq))).limit(1);
|
|
555
773
|
return rows[0] ? fromCheckpointRow(rows[0]) : null;
|
|
556
774
|
}
|
|
@@ -568,7 +786,15 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
568
786
|
const unique = [
|
|
569
787
|
...new Set(seqs)
|
|
570
788
|
];
|
|
571
|
-
|
|
789
|
+
if (this.hot) {
|
|
790
|
+
if (unique.length === 0) return [];
|
|
791
|
+
const rows2 = await this.hot.query(SELECT_CHECKPOINTS_FOR_SETTLE, [
|
|
792
|
+
runId,
|
|
793
|
+
unique
|
|
794
|
+
]);
|
|
795
|
+
return rows2.map((raw) => fromCheckpointRow(CPS_NO_INPUT.decode(raw)));
|
|
796
|
+
}
|
|
797
|
+
const { input: _input, ...columns } = getTableColumns2(durableStepCheckpoints);
|
|
572
798
|
const rows = [];
|
|
573
799
|
for (let at = 0; at < unique.length; at += 500) {
|
|
574
800
|
rows.push(...await this.db.select(columns).from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), inArray(durableStepCheckpoints.seq, unique.slice(at, at + 500)))));
|
|
@@ -579,6 +805,10 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
579
805
|
}));
|
|
580
806
|
}
|
|
581
807
|
async saveCheckpoint(checkpoint) {
|
|
808
|
+
if (this.hot) {
|
|
809
|
+
await this.hot.query(UPSERT_CHECKPOINT, CPS.encodeRow(toCheckpointRow(checkpoint)));
|
|
810
|
+
return;
|
|
811
|
+
}
|
|
582
812
|
await upsertCheckpoint(this.db, checkpoint);
|
|
583
813
|
}
|
|
584
814
|
async saveCheckpoints(checkpoints) {
|
|
@@ -605,7 +835,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
605
835
|
async saveCheckpointsIfPending(checkpoints) {
|
|
606
836
|
const wrote = checkpoints.map(() => false);
|
|
607
837
|
if (checkpoints.length === 0) return wrote;
|
|
608
|
-
await this.
|
|
838
|
+
await this.inTransactionIf(oneStatement(checkpoints), async (tx) => {
|
|
609
839
|
for (const round of distinctRounds(checkpoints)) {
|
|
610
840
|
for (let at = 0; at < round.length; at += CHECKPOINT_BATCH_ROWS) {
|
|
611
841
|
const chunk = round.slice(at, at + CHECKPOINT_BATCH_ROWS);
|
|
@@ -629,7 +859,7 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
629
859
|
async settleCheckpointsIfPending(settlements) {
|
|
630
860
|
const wrote = settlements.map(() => false);
|
|
631
861
|
if (settlements.length === 0) return wrote;
|
|
632
|
-
await this.
|
|
862
|
+
await this.inTransactionIf(oneStatement(settlements), async (tx) => {
|
|
633
863
|
for (const round of distinctRounds(settlements)) {
|
|
634
864
|
for (let at = 0; at < round.length; at += CHECKPOINT_BATCH_ROWS) {
|
|
635
865
|
const chunk = round.slice(at, at + CHECKPOINT_BATCH_ROWS);
|
|
@@ -650,6 +880,84 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
650
880
|
});
|
|
651
881
|
return wrote;
|
|
652
882
|
}
|
|
883
|
+
async settleResultsIfPending(results) {
|
|
884
|
+
const out = results.map(() => null);
|
|
885
|
+
const seen = /* @__PURE__ */ new Set();
|
|
886
|
+
const sent = results.flatMap((r, i) => {
|
|
887
|
+
const key = rowKey(r);
|
|
888
|
+
if (seen.has(key)) return [];
|
|
889
|
+
seen.add(key);
|
|
890
|
+
return [
|
|
891
|
+
i
|
|
892
|
+
];
|
|
893
|
+
});
|
|
894
|
+
if (sent.length === 0) return out;
|
|
895
|
+
if (this.hot && sent.length <= HOT_SETTLE_MAX_ROWS) {
|
|
896
|
+
const rows = await this.hot.query(settleResultsText(sent.length), sent.flatMap((i) => settleResultValues(results[i])));
|
|
897
|
+
const byKey = new Map(sent.map((i) => [
|
|
898
|
+
rowKey(results[i]),
|
|
899
|
+
i
|
|
900
|
+
]));
|
|
901
|
+
for (const raw of rows) {
|
|
902
|
+
const cp = fromCheckpointRow(CPS_NO_INPUT.decode(raw));
|
|
903
|
+
const i = byKey.get(rowKey(cp));
|
|
904
|
+
if (i !== void 0) out[i] = cp;
|
|
905
|
+
}
|
|
906
|
+
return out;
|
|
907
|
+
}
|
|
908
|
+
await this.inTransactionIf(sent.length <= CHECKPOINT_BATCH_ROWS, async (tx) => {
|
|
909
|
+
for (let at = 0; at < sent.length; at += CHECKPOINT_BATCH_ROWS) {
|
|
910
|
+
const chunk = sent.slice(at, at + CHECKPOINT_BATCH_ROWS);
|
|
911
|
+
const rows = rowsOf(await tx.execute(settleResultsFrom(chunk.map((i) => results[i]))));
|
|
912
|
+
const byKey = new Map(chunk.map((i) => [
|
|
913
|
+
rowKey(results[i]),
|
|
914
|
+
i
|
|
915
|
+
]));
|
|
916
|
+
for (const raw of rows) {
|
|
917
|
+
const cp = fromCheckpointRow(settledRowFromDriver(raw));
|
|
918
|
+
const i = byKey.get(rowKey(cp));
|
|
919
|
+
if (i !== void 0) out[i] = cp;
|
|
920
|
+
}
|
|
921
|
+
}
|
|
922
|
+
});
|
|
923
|
+
return out;
|
|
924
|
+
}
|
|
925
|
+
async insertCheckpointIfAbsent(checkpoint) {
|
|
926
|
+
if (this.hot) {
|
|
927
|
+
const values = CPS.encodeRow(toCheckpointRow(checkpoint));
|
|
928
|
+
return (await this.hot.query(INSERT_CHECKPOINT_IF_ABSENT, values)).length === 1;
|
|
929
|
+
}
|
|
930
|
+
const rows = await this.db.insert(durableStepCheckpoints).values(toCheckpointRow(checkpoint)).onConflictDoNothing({
|
|
931
|
+
target: [
|
|
932
|
+
durableStepCheckpoints.runId,
|
|
933
|
+
durableStepCheckpoints.seq
|
|
934
|
+
]
|
|
935
|
+
}).returning({
|
|
936
|
+
seq: durableStepCheckpoints.seq
|
|
937
|
+
});
|
|
938
|
+
return rows.length === 1;
|
|
939
|
+
}
|
|
940
|
+
async tryLockRunAndGet(runId, owner, leaseUntilMs, nowMs) {
|
|
941
|
+
if (this.hot) {
|
|
942
|
+
const rows2 = await this.hot.query(`${LOCK_RUN}${this.hotScope.text.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + 3}`)} RETURNING ${RUNS.list}`, [
|
|
943
|
+
runId,
|
|
944
|
+
owner,
|
|
945
|
+
lockTime(leaseUntilMs),
|
|
946
|
+
lockTime(nowMs),
|
|
947
|
+
...this.hotScope.values
|
|
948
|
+
]);
|
|
949
|
+
return rows2[0] ? fromRunRow(RUNS.decode(rows2[0])) : null;
|
|
950
|
+
}
|
|
951
|
+
const rows = await this.db.update(durableWorkflowRuns).set({
|
|
952
|
+
lockedBy: owner,
|
|
953
|
+
lockedUntil: new Date(leaseUntilMs)
|
|
954
|
+
}).where(and(eq(durableWorkflowRuns.id, runId), or(isNull(durableWorkflowRuns.lockedUntil), lte(durableWorkflowRuns.lockedUntil, new Date(nowMs))), this.scope())).returning();
|
|
955
|
+
return rows[0] ? fromRunRow(rows[0]) : null;
|
|
956
|
+
}
|
|
957
|
+
/** Run `work` on the db as is when it is one statement (atomic by itself), else in a transaction. */
|
|
958
|
+
inTransactionIf(single, work) {
|
|
959
|
+
return single ? work(this.db) : this.db.transaction((tx) => work(tx));
|
|
960
|
+
}
|
|
653
961
|
async transaction(work) {
|
|
654
962
|
return this.db.transaction(async (tx) => work({
|
|
655
963
|
raw: tx,
|
|
@@ -683,12 +991,45 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
683
991
|
const rows = await this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.status, "pending"), namespaceFilter(namespace), this.scope())).orderBy(asc(durableWorkflowRuns.createdAt)).limit(limit);
|
|
684
992
|
return rows.map(fromRunRow);
|
|
685
993
|
}
|
|
994
|
+
async claimPendingRuns(limit, owner, leaseUntilMs, nowMs, namespace) {
|
|
995
|
+
if (limit <= 0) return [];
|
|
996
|
+
const filters = and(eq(durableWorkflowRuns.status, "pending"), or(isNull(durableWorkflowRuns.lockedUntil), lte(durableWorkflowRuns.lockedUntil, new Date(nowMs))), namespaceFilter(namespace), this.scope());
|
|
997
|
+
const returning = sql3.join(RUNS.columns.map(([, column]) => sql3`r.${sql3.identifier(column.name)}`), sql3`, `);
|
|
998
|
+
const rows = rowsOf(
|
|
999
|
+
// A CTE, MATERIALIZED, picks the rows once. As a subquery in UPDATE ... FROM, Postgres may
|
|
1000
|
+
// rescan it, and each rescan skips the rows this statement already updated and takes the
|
|
1001
|
+
// next ones, so a claim of `limit` rows could lease every free pending run.
|
|
1002
|
+
await this.db.execute(sql3`WITH c AS MATERIALIZED (
|
|
1003
|
+
SELECT ${durableWorkflowRuns.id} AS claimed_id FROM ${durableWorkflowRuns}
|
|
1004
|
+
WHERE ${filters}
|
|
1005
|
+
ORDER BY ${durableWorkflowRuns.createdAt}, ${durableWorkflowRuns.id}
|
|
1006
|
+
LIMIT ${limit}
|
|
1007
|
+
FOR UPDATE SKIP LOCKED
|
|
1008
|
+
)
|
|
1009
|
+
UPDATE ${durableWorkflowRuns} AS r
|
|
1010
|
+
SET ${sql3.identifier(getTableColumns2(durableWorkflowRuns).lockedBy.name)} = ${owner},
|
|
1011
|
+
${sql3.identifier(getTableColumns2(durableWorkflowRuns).lockedUntil.name)} = ${new Date(leaseUntilMs).toISOString()}::timestamptz
|
|
1012
|
+
FROM c
|
|
1013
|
+
WHERE r.${sql3.identifier(getTableColumns2(durableWorkflowRuns).id.name)} = c.claimed_id
|
|
1014
|
+
RETURNING ${returning}`)
|
|
1015
|
+
);
|
|
1016
|
+
return rows.map((raw) => fromRunRow(RUNS.decode(raw))).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
|
|
1017
|
+
}
|
|
686
1018
|
async listDueTimers(nowMs, namespace, limit) {
|
|
687
1019
|
const query = this.db.select().from(durableWorkflowRuns).where(and(eq(durableWorkflowRuns.status, "suspended"), isNotNull(durableWorkflowRuns.wakeAt), lte(durableWorkflowRuns.wakeAt, new Date(nowMs)), namespaceFilter(namespace), this.scope())).orderBy(asc(durableWorkflowRuns.wakeAt));
|
|
688
1020
|
const rows = limit !== void 0 ? await query.limit(limit) : await query;
|
|
689
1021
|
return rows.map(fromRunRow);
|
|
690
1022
|
}
|
|
691
1023
|
async tryLockRun(runId, owner, leaseUntilMs, nowMs) {
|
|
1024
|
+
if (this.hot) {
|
|
1025
|
+
const rows2 = await this.hot.query(`${LOCK_RUN} RETURNING "id"`, [
|
|
1026
|
+
runId,
|
|
1027
|
+
owner,
|
|
1028
|
+
lockTime(leaseUntilMs),
|
|
1029
|
+
lockTime(nowMs)
|
|
1030
|
+
]);
|
|
1031
|
+
return rows2.length === 1;
|
|
1032
|
+
}
|
|
692
1033
|
const rows = await this.db.update(durableWorkflowRuns).set({
|
|
693
1034
|
lockedBy: owner,
|
|
694
1035
|
lockedUntil: new Date(leaseUntilMs)
|
|
@@ -698,12 +1039,29 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
698
1039
|
return rows.length === 1;
|
|
699
1040
|
}
|
|
700
1041
|
async releaseRunLock(runId, owner) {
|
|
1042
|
+
if (this.hot) {
|
|
1043
|
+
await (owner === void 0 ? this.hot.query(RELEASE_LOCK, [
|
|
1044
|
+
runId
|
|
1045
|
+
]) : this.hot.query(`${RELEASE_LOCK} AND "locked_by" = $2`, [
|
|
1046
|
+
runId,
|
|
1047
|
+
owner
|
|
1048
|
+
]));
|
|
1049
|
+
return;
|
|
1050
|
+
}
|
|
701
1051
|
await this.db.update(durableWorkflowRuns).set({
|
|
702
1052
|
lockedBy: null,
|
|
703
1053
|
lockedUntil: null
|
|
704
1054
|
}).where(owner === void 0 ? eq(durableWorkflowRuns.id, runId) : and(eq(durableWorkflowRuns.id, runId), eq(durableWorkflowRuns.lockedBy, owner)));
|
|
705
1055
|
}
|
|
706
1056
|
async renewRunLock(runId, owner, leaseUntilMs) {
|
|
1057
|
+
if (this.hot) {
|
|
1058
|
+
const rows2 = await this.hot.query(RENEW_LOCK, [
|
|
1059
|
+
runId,
|
|
1060
|
+
owner,
|
|
1061
|
+
lockTime(leaseUntilMs)
|
|
1062
|
+
]);
|
|
1063
|
+
return rows2.length === 1;
|
|
1064
|
+
}
|
|
707
1065
|
const rows = await this.db.update(durableWorkflowRuns).set({
|
|
708
1066
|
lockedUntil: new Date(leaseUntilMs)
|
|
709
1067
|
}).where(and(eq(durableWorkflowRuns.id, runId), eq(durableWorkflowRuns.lockedBy, owner))).returning({
|
|
@@ -832,7 +1190,26 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
832
1190
|
return rows.map(fromCheckpointRow);
|
|
833
1191
|
}
|
|
834
1192
|
async listCheckpointsForReplay(runId) {
|
|
835
|
-
|
|
1193
|
+
if (this.hot) {
|
|
1194
|
+
const rows2 = (await this.hot.query(SELECT_REPLAY, [
|
|
1195
|
+
runId
|
|
1196
|
+
])).map((raw) => CPS_NO_INPUT.decode(raw));
|
|
1197
|
+
const open2 = rows2.filter((row) => row.status !== "completed").map((row) => row.seq);
|
|
1198
|
+
const inputs2 = /* @__PURE__ */ new Map();
|
|
1199
|
+
if (open2.length > 0) {
|
|
1200
|
+
for (const raw of await this.hot.query(SELECT_INPUTS, [
|
|
1201
|
+
runId,
|
|
1202
|
+
open2
|
|
1203
|
+
])) {
|
|
1204
|
+
inputs2.set(Number(raw.seq), CPS.decode(raw).input);
|
|
1205
|
+
}
|
|
1206
|
+
}
|
|
1207
|
+
return rows2.map((row) => fromCheckpointRow({
|
|
1208
|
+
...row,
|
|
1209
|
+
input: inputs2.get(row.seq) ?? null
|
|
1210
|
+
}));
|
|
1211
|
+
}
|
|
1212
|
+
const { input: _input, ...columns } = getTableColumns2(durableStepCheckpoints);
|
|
836
1213
|
const rows = await this.db.select(columns).from(durableStepCheckpoints).where(eq(durableStepCheckpoints.runId, runId)).orderBy(asc(durableStepCheckpoints.seq));
|
|
837
1214
|
const open = rows.filter((row) => row.status !== "completed").map((row) => row.seq);
|
|
838
1215
|
const inputs = /* @__PURE__ */ new Map();
|
|
@@ -854,6 +1231,15 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
854
1231
|
}
|
|
855
1232
|
async hasCheckpoints(runId, fromSeq, toSeq, statuses) {
|
|
856
1233
|
if (statuses.length === 0) return false;
|
|
1234
|
+
if (this.hot) {
|
|
1235
|
+
const rows2 = await this.hot.query(HAS_CHECKPOINTS, [
|
|
1236
|
+
runId,
|
|
1237
|
+
fromSeq,
|
|
1238
|
+
toSeq,
|
|
1239
|
+
statuses
|
|
1240
|
+
]);
|
|
1241
|
+
return rows2.length > 0;
|
|
1242
|
+
}
|
|
857
1243
|
const rows = await this.db.select({
|
|
858
1244
|
seq: durableStepCheckpoints.seq
|
|
859
1245
|
}).from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), gte(durableStepCheckpoints.seq, fromSeq), lte(durableStepCheckpoints.seq, toSeq), inArray(durableStepCheckpoints.status, statuses))).orderBy(desc(durableStepCheckpoints.seq)).limit(1);
|
|
@@ -861,6 +1247,15 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
861
1247
|
}
|
|
862
1248
|
async countCheckpoints(runId, fromSeq, toSeq, statuses) {
|
|
863
1249
|
if (statuses.length === 0) return 0;
|
|
1250
|
+
if (this.hot) {
|
|
1251
|
+
const rows2 = await this.hot.query(COUNT_CHECKPOINTS, [
|
|
1252
|
+
runId,
|
|
1253
|
+
fromSeq,
|
|
1254
|
+
toSeq,
|
|
1255
|
+
statuses
|
|
1256
|
+
]);
|
|
1257
|
+
return Number(rows2[0]?.n ?? 0);
|
|
1258
|
+
}
|
|
864
1259
|
const rows = await this.db.select({
|
|
865
1260
|
count: sql3`count(*)`.mapWith(Number)
|
|
866
1261
|
}).from(durableStepCheckpoints).where(and(eq(durableStepCheckpoints.runId, runId), gte(durableStepCheckpoints.seq, fromSeq), lte(durableStepCheckpoints.seq, toSeq), inArray(durableStepCheckpoints.status, statuses)));
|
|
@@ -993,6 +1388,16 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
993
1388
|
});
|
|
994
1389
|
}
|
|
995
1390
|
async takeBufferedSignal(token) {
|
|
1391
|
+
if (this.hot) {
|
|
1392
|
+
const [row2] = await this.hot.query(TAKE_BUFFERED_SIGNAL, [
|
|
1393
|
+
token
|
|
1394
|
+
]);
|
|
1395
|
+
if (!row2) return null;
|
|
1396
|
+
const payload = row2.payload == null ? null : SIGNAL_PAYLOAD.mapFromDriverValue(row2.payload);
|
|
1397
|
+
return {
|
|
1398
|
+
payload: payload ?? void 0
|
|
1399
|
+
};
|
|
1400
|
+
}
|
|
996
1401
|
const oldest = this.db.select({
|
|
997
1402
|
id: durableBufferedSignals.id
|
|
998
1403
|
}).from(durableBufferedSignals).where(eq(durableBufferedSignals.token, token)).orderBy(asc(durableBufferedSignals.id)).limit(1).for("update", {
|
|
@@ -1006,6 +1411,59 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
1006
1411
|
payload: row.payload ?? void 0
|
|
1007
1412
|
} : null;
|
|
1008
1413
|
}
|
|
1414
|
+
async takeOldestBufferedSignal(tokens) {
|
|
1415
|
+
if (tokens.length === 0) return null;
|
|
1416
|
+
const oldest = this.db.select({
|
|
1417
|
+
id: durableBufferedSignals.id
|
|
1418
|
+
}).from(durableBufferedSignals).where(inArray(durableBufferedSignals.token, [
|
|
1419
|
+
...new Set(tokens)
|
|
1420
|
+
])).orderBy(asc(durableBufferedSignals.id)).limit(1).for("update", {
|
|
1421
|
+
skipLocked: true
|
|
1422
|
+
});
|
|
1423
|
+
const rows = await this.db.delete(durableBufferedSignals).where(inArray(durableBufferedSignals.id, oldest)).returning({
|
|
1424
|
+
token: durableBufferedSignals.token,
|
|
1425
|
+
payload: durableBufferedSignals.payload
|
|
1426
|
+
});
|
|
1427
|
+
const row = rows[0];
|
|
1428
|
+
return row ? {
|
|
1429
|
+
token: row.token,
|
|
1430
|
+
payload: row.payload ?? void 0
|
|
1431
|
+
} : null;
|
|
1432
|
+
}
|
|
1433
|
+
async claimSignalId(token, id, expiresAt, nowMs) {
|
|
1434
|
+
const rows = await this.db.insert(durableSignalIds).values({
|
|
1435
|
+
token,
|
|
1436
|
+
signalId: id,
|
|
1437
|
+
expiresAt: new Date(expiresAt)
|
|
1438
|
+
}).onConflictDoUpdate({
|
|
1439
|
+
target: [
|
|
1440
|
+
durableSignalIds.token,
|
|
1441
|
+
durableSignalIds.signalId
|
|
1442
|
+
],
|
|
1443
|
+
set: {
|
|
1444
|
+
expiresAt: new Date(expiresAt)
|
|
1445
|
+
},
|
|
1446
|
+
setWhere: lte(durableSignalIds.expiresAt, new Date(nowMs))
|
|
1447
|
+
}).returning({
|
|
1448
|
+
token: durableSignalIds.token
|
|
1449
|
+
});
|
|
1450
|
+
return rows.length > 0;
|
|
1451
|
+
}
|
|
1452
|
+
async releaseSignalId(token, id) {
|
|
1453
|
+
await this.db.delete(durableSignalIds).where(and(eq(durableSignalIds.token, token), eq(durableSignalIds.signalId, id)));
|
|
1454
|
+
}
|
|
1455
|
+
async deleteExpiredSignalIds(nowMs, limit) {
|
|
1456
|
+
const expired = this.db.select({
|
|
1457
|
+
token: durableSignalIds.token,
|
|
1458
|
+
signalId: durableSignalIds.signalId
|
|
1459
|
+
}).from(durableSignalIds).where(lte(durableSignalIds.expiresAt, new Date(nowMs))).limit(limit).for("update", {
|
|
1460
|
+
skipLocked: true
|
|
1461
|
+
});
|
|
1462
|
+
const rows = await this.db.delete(durableSignalIds).where(sql3`(${durableSignalIds.token}, ${durableSignalIds.signalId}) in (${expired})`).returning({
|
|
1463
|
+
token: durableSignalIds.token
|
|
1464
|
+
});
|
|
1465
|
+
return rows.length;
|
|
1466
|
+
}
|
|
1009
1467
|
async listBufferedSignals(tokenPrefix, afterId, limit) {
|
|
1010
1468
|
const rows = await this.db.select().from(durableBufferedSignals).where(and(like(durableBufferedSignals.token, `${escapeLike(tokenPrefix)}%`), afterId !== void 0 ? gt(durableBufferedSignals.id, Number(afterId)) : void 0)).orderBy(asc(durableBufferedSignals.id)).limit(limit);
|
|
1011
1469
|
return rows.filter((r) => r.token.startsWith(tokenPrefix)).map((r) => ({
|
|
@@ -1027,6 +1485,19 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
1027
1485
|
});
|
|
1028
1486
|
}
|
|
1029
1487
|
async listBufferedEvents(name, limit) {
|
|
1488
|
+
if (this.hot) {
|
|
1489
|
+
return (await this.hot.query(LIST_BUFFERED_EVENTS, [
|
|
1490
|
+
name,
|
|
1491
|
+
limit
|
|
1492
|
+
])).map((raw) => {
|
|
1493
|
+
const r = EVENTS.decode(raw);
|
|
1494
|
+
return {
|
|
1495
|
+
id: r.id,
|
|
1496
|
+
payload: r.payload ?? void 0,
|
|
1497
|
+
publishedAt: r.publishedAt.getTime()
|
|
1498
|
+
};
|
|
1499
|
+
});
|
|
1500
|
+
}
|
|
1030
1501
|
const rows = await this.db.select().from(durableBufferedEvents).where(eq(durableBufferedEvents.name, name)).orderBy(asc(durableBufferedEvents.publishedAt), asc(durableBufferedEvents.id)).limit(limit);
|
|
1031
1502
|
return rows.map((r) => ({
|
|
1032
1503
|
id: r.id,
|
|
@@ -1035,6 +1506,9 @@ var DrizzlePgStateStore = class _DrizzlePgStateStore {
|
|
|
1035
1506
|
}));
|
|
1036
1507
|
}
|
|
1037
1508
|
async removeBufferedEvent(id) {
|
|
1509
|
+
if (this.hot) return (await this.hot.query(REMOVE_BUFFERED_EVENT, [
|
|
1510
|
+
id
|
|
1511
|
+
])).length === 1;
|
|
1038
1512
|
const rows = await this.db.delete(durableBufferedEvents).where(eq(durableBufferedEvents.id, id)).returning({
|
|
1039
1513
|
id: durableBufferedEvents.id
|
|
1040
1514
|
});
|
|
@@ -1046,6 +1520,68 @@ function escapeLike(value) {
|
|
|
1046
1520
|
}
|
|
1047
1521
|
__name(escapeLike, "escapeLike");
|
|
1048
1522
|
var CHECKPOINT_BATCH_ROWS = 500;
|
|
1523
|
+
var RUNS = new TableCodec(durableWorkflowRuns);
|
|
1524
|
+
var CPS = new TableCodec(durableStepCheckpoints);
|
|
1525
|
+
var CPS_NO_INPUT = new TableCodec(durableStepCheckpoints, [
|
|
1526
|
+
"input"
|
|
1527
|
+
]);
|
|
1528
|
+
var EVENTS = new TableCodec(durableBufferedEvents);
|
|
1529
|
+
var SIGNAL_PAYLOAD = getTableColumns2(durableBufferedSignals).payload;
|
|
1530
|
+
var T_RUNS = quote(getTableName2(durableWorkflowRuns));
|
|
1531
|
+
var T_CPS = quote(getTableName2(durableStepCheckpoints));
|
|
1532
|
+
var T_EVENTS = quote(getTableName2(durableBufferedEvents));
|
|
1533
|
+
var T_SIGNALS = quote(getTableName2(durableBufferedSignals));
|
|
1534
|
+
var T_ATTRIBUTES = quote(getTableName2(durableRunAttributes));
|
|
1535
|
+
var SELECT_RUN = `SELECT ${RUNS.list} FROM ${T_RUNS} WHERE "id" = $1`;
|
|
1536
|
+
var INSERT_RUN = `INSERT INTO ${T_RUNS} (${RUNS.list}) VALUES (${placeholders(1, RUNS.columns.length)})`;
|
|
1537
|
+
var DELETE_ATTRIBUTES = `DELETE FROM ${T_ATTRIBUTES} WHERE "run_id" = $1`;
|
|
1538
|
+
var LOCK_RUN = `UPDATE ${T_RUNS} SET "locked_by" = $2, "locked_until" = $3 WHERE "id" = $1 AND ("locked_until" IS NULL OR "locked_until" <= $4)`;
|
|
1539
|
+
var RELEASE_LOCK = `UPDATE ${T_RUNS} SET "locked_by" = NULL, "locked_until" = NULL WHERE "id" = $1`;
|
|
1540
|
+
var RENEW_LOCK = `UPDATE ${T_RUNS} SET "locked_until" = $3 WHERE "id" = $1 AND "locked_by" = $2 RETURNING "id"`;
|
|
1541
|
+
var SELECT_CHECKPOINT = `SELECT ${CPS.list} FROM ${T_CPS} WHERE "run_id" = $1 AND "seq" = $2 LIMIT 1`;
|
|
1542
|
+
var SELECT_CHECKPOINTS_FOR_SETTLE = `SELECT ${CPS_NO_INPUT.list} FROM ${T_CPS} WHERE "run_id" = $1 AND "seq" = ANY($2::integer[]) ORDER BY "seq"`;
|
|
1543
|
+
var SELECT_REPLAY = `SELECT ${CPS_NO_INPUT.list} FROM ${T_CPS} WHERE "run_id" = $1 ORDER BY "seq"`;
|
|
1544
|
+
var SELECT_INPUTS = `SELECT "seq", "input" FROM ${T_CPS} WHERE "run_id" = $1 AND "seq" = ANY($2::integer[])`;
|
|
1545
|
+
var CHECKPOINT_VALUES = `(${CPS.list}) VALUES (${placeholders(1, CPS.columns.length)})`;
|
|
1546
|
+
var UPSERT_CHECKPOINT = `INSERT INTO ${T_CPS} ${CHECKPOINT_VALUES} ON CONFLICT ("run_id", "seq") DO UPDATE SET ${CPS.columns.map(([, c]) => `${quote(c.name)} = EXCLUDED.${quote(c.name)}`).join(", ")}`;
|
|
1547
|
+
var INSERT_CHECKPOINT_IF_ABSENT = `INSERT INTO ${T_CPS} ${CHECKPOINT_VALUES} ON CONFLICT ("run_id", "seq") DO NOTHING RETURNING "seq"`;
|
|
1548
|
+
var CHECKPOINT_RANGE = `FROM ${T_CPS} WHERE "run_id" = $1 AND "seq" >= $2 AND "seq" <= $3 AND "status" = ANY($4::text[])`;
|
|
1549
|
+
var HAS_CHECKPOINTS = `SELECT "seq" ${CHECKPOINT_RANGE} ORDER BY "seq" DESC LIMIT 1`;
|
|
1550
|
+
var COUNT_CHECKPOINTS = `SELECT count(*)::integer AS "n" ${CHECKPOINT_RANGE}`;
|
|
1551
|
+
var LIST_BUFFERED_EVENTS = `SELECT ${EVENTS.list} FROM ${T_EVENTS} WHERE "name" = $1 ORDER BY "published_at", "id" LIMIT $2`;
|
|
1552
|
+
var REMOVE_BUFFERED_EVENT = `DELETE FROM ${T_EVENTS} WHERE "id" = $1 RETURNING "id"`;
|
|
1553
|
+
var TAKE_BUFFERED_SIGNAL = `WITH taken AS MATERIALIZED (SELECT "id" FROM ${T_SIGNALS} WHERE "token" = $1 ORDER BY "id" LIMIT 1 FOR UPDATE SKIP LOCKED) DELETE FROM ${T_SIGNALS} WHERE "id" IN (SELECT "id" FROM taken) RETURNING "payload"`;
|
|
1554
|
+
var HOT_SETTLE_MAX_ROWS = 64;
|
|
1555
|
+
var settleTexts = /* @__PURE__ */ new Map();
|
|
1556
|
+
var lockTime = /* @__PURE__ */ __name((ms2) => RUNS.encode("lockedUntil", new Date(ms2)), "lockTime");
|
|
1557
|
+
function settleResultsText(n) {
|
|
1558
|
+
let text2 = settleTexts.get(n);
|
|
1559
|
+
if (text2 !== void 0) return text2;
|
|
1560
|
+
const rows = Array.from({
|
|
1561
|
+
length: n
|
|
1562
|
+
}, (_, r) => {
|
|
1563
|
+
const p = /* @__PURE__ */ __name((k) => `$${r * 8 + k}`, "p");
|
|
1564
|
+
return `(${p(1)}::text, ${p(2)}::integer, ${p(3)}::text, ${p(4)}::jsonb, ${p(5)}::jsonb, ${p(6)}::jsonb, ${p(7)}::timestamptz, ${p(8)}::timestamptz)`;
|
|
1565
|
+
});
|
|
1566
|
+
text2 = `UPDATE ${T_CPS} AS c SET status = v.status, output = CASE WHEN v.status = 'completed' THEN v.output ELSE c.output END, error = v.error, events = COALESCE(v.events, c.events), started_at = COALESCE(v.started_at, c.started_at), finished_at = v.finished_at FROM (VALUES ${rows.join(", ")}) AS v(run_id, seq, status, output, error, events, started_at, finished_at) WHERE c.run_id = v.run_id AND c.seq = v.seq AND c.status = 'pending' AND NOT EXISTS (SELECT 1 FROM ${T_RUNS} AS r WHERE r.id = c.run_id AND r.status IN ('cancelled', 'completed')) RETURNING ${CPS_NO_INPUT.columns.map(([, c]) => `c.${quote(c.name)}`).join(", ")}`;
|
|
1567
|
+
settleTexts.set(n, text2);
|
|
1568
|
+
return text2;
|
|
1569
|
+
}
|
|
1570
|
+
__name(settleResultsText, "settleResultsText");
|
|
1571
|
+
function settleResultValues(r) {
|
|
1572
|
+
const json = /* @__PURE__ */ __name((v) => v == null ? null : JSON.stringify(v), "json");
|
|
1573
|
+
return [
|
|
1574
|
+
r.runId,
|
|
1575
|
+
r.seq,
|
|
1576
|
+
r.status,
|
|
1577
|
+
json(r.status === "completed" ? r.output : null),
|
|
1578
|
+
json(r.error),
|
|
1579
|
+
json(r.events),
|
|
1580
|
+
r.startedAt ? r.startedAt.toISOString() : null,
|
|
1581
|
+
r.finishedAt.toISOString()
|
|
1582
|
+
];
|
|
1583
|
+
}
|
|
1584
|
+
__name(settleResultValues, "settleResultValues");
|
|
1049
1585
|
var rowKey = /* @__PURE__ */ __name((cp) => `${cp.seq}:${cp.runId}`, "rowKey");
|
|
1050
1586
|
function distinctRounds(checkpoints) {
|
|
1051
1587
|
const rounds = [];
|
|
@@ -1092,6 +1628,48 @@ function settleIfPendingFrom(settlements) {
|
|
|
1092
1628
|
RETURNING c.run_id, c.seq`;
|
|
1093
1629
|
}
|
|
1094
1630
|
__name(settleIfPendingFrom, "settleIfPendingFrom");
|
|
1631
|
+
function oneStatement(rows) {
|
|
1632
|
+
if (rows.length > CHECKPOINT_BATCH_ROWS) return false;
|
|
1633
|
+
const keys = new Set(rows.map(rowKey));
|
|
1634
|
+
return keys.size === rows.length;
|
|
1635
|
+
}
|
|
1636
|
+
__name(oneStatement, "oneStatement");
|
|
1637
|
+
var SETTLED_COLUMNS = (() => {
|
|
1638
|
+
const { input: _input, ...columns } = getTableColumns2(durableStepCheckpoints);
|
|
1639
|
+
return columns;
|
|
1640
|
+
})();
|
|
1641
|
+
function settledRowFromDriver(raw) {
|
|
1642
|
+
const row = {
|
|
1643
|
+
input: null
|
|
1644
|
+
};
|
|
1645
|
+
for (const [key, column] of Object.entries(SETTLED_COLUMNS)) {
|
|
1646
|
+
const value = raw[column.name];
|
|
1647
|
+
row[key] = value == null ? null : column.mapFromDriverValue(value);
|
|
1648
|
+
}
|
|
1649
|
+
return row;
|
|
1650
|
+
}
|
|
1651
|
+
__name(settledRowFromDriver, "settledRowFromDriver");
|
|
1652
|
+
function settleResultsFrom(results) {
|
|
1653
|
+
const json = /* @__PURE__ */ __name((v) => v == null ? null : JSON.stringify(v), "json");
|
|
1654
|
+
const values = results.map((r) => sql3`(${r.runId}::text, ${r.seq}::integer, ${r.status}::text, ${json(r.status === "completed" ? r.output : null)}::jsonb, ${json(r.error)}::jsonb, ${json(r.events)}::jsonb, ${r.startedAt ? r.startedAt.toISOString() : null}::timestamptz, ${r.finishedAt.toISOString()}::timestamptz)`);
|
|
1655
|
+
const returning = sql3.join(Object.values(SETTLED_COLUMNS).map((column) => sql3`c.${sql3.identifier(column.name)}`), sql3`, `);
|
|
1656
|
+
return sql3`UPDATE ${durableStepCheckpoints} AS c SET
|
|
1657
|
+
status = v.status,
|
|
1658
|
+
output = CASE WHEN v.status = 'completed' THEN v.output ELSE c.output END,
|
|
1659
|
+
error = v.error,
|
|
1660
|
+
events = COALESCE(v.events, c.events),
|
|
1661
|
+
started_at = COALESCE(v.started_at, c.started_at),
|
|
1662
|
+
finished_at = v.finished_at
|
|
1663
|
+
FROM (VALUES ${sql3.join(values, sql3`, `)}) AS v(run_id, seq, status, output, error, events,
|
|
1664
|
+
started_at, finished_at)
|
|
1665
|
+
WHERE c.run_id = v.run_id AND c.seq = v.seq AND c.status = 'pending'
|
|
1666
|
+
AND NOT EXISTS (
|
|
1667
|
+
SELECT 1 FROM ${durableWorkflowRuns} AS r
|
|
1668
|
+
WHERE r.id = c.run_id AND r.status IN ('cancelled', 'completed')
|
|
1669
|
+
)
|
|
1670
|
+
RETURNING ${returning}`;
|
|
1671
|
+
}
|
|
1672
|
+
__name(settleResultsFrom, "settleResultsFrom");
|
|
1095
1673
|
async function upsertCheckpoint(db, cp) {
|
|
1096
1674
|
const row = toCheckpointRow(cp);
|
|
1097
1675
|
await db.insert(durableStepCheckpoints).values(row).onConflictDoUpdate({
|
|
@@ -1290,7 +1868,7 @@ function fromScheduleRow(row) {
|
|
|
1290
1868
|
}
|
|
1291
1869
|
__name(fromScheduleRow, "fromScheduleRow");
|
|
1292
1870
|
function excludedSet(table, only) {
|
|
1293
|
-
return Object.fromEntries(Object.entries(
|
|
1871
|
+
return Object.fromEntries(Object.entries(getTableColumns2(table)).filter(([key]) => !only || only.includes(key)).map(([key, column]) => [
|
|
1294
1872
|
key,
|
|
1295
1873
|
sql3.raw(`excluded."${column.name}"`)
|
|
1296
1874
|
]));
|
|
@@ -1308,6 +1886,7 @@ export {
|
|
|
1308
1886
|
durablePgSchema,
|
|
1309
1887
|
durableRunAttributes,
|
|
1310
1888
|
durableSchedules,
|
|
1889
|
+
durableSignalIds,
|
|
1311
1890
|
durableSignalWaiters,
|
|
1312
1891
|
durableStepCheckpoints,
|
|
1313
1892
|
durableWorkflowRuns,
|