@tenetkit/pg 0.28.0

package/dist/postgres/session-store.js

@@ -0,0 +1,388 @@
+import { Effect, Schema } from "effect";
+import { Session } from "tenetkit";
+import { SqlClient } from "effect/unstable/sql";
+import { handoffPayload } from "tenetkit/runtime/driver/handoff-session";
+import {} from "tenetkit/runtime/driver/sql/session-store";
+import { PostgresSessionStorage } from "./session-storage.js";
+const { advanceSession, entryPayloadEquivalence, insertEntry, loadEntries, lockSession, pathFromRows, requireActive, storeError, toEntry, } = PostgresSessionStorage;
+const appendMatches = (entry, input, parentId) => entry.parentId === parentId && entryPayloadEquivalence(entry, input);
+const completedPayload = (input) => ({
+    _tag: "ModelResponse",
+    content: input.content,
+    metadata: { modelResponseDigest: input.digest },
+});
+const interruptedPayload = (input) => ({
+    _tag: "ModelResponse",
+    content: input.content,
+    metadata: { interruptionDigest: input.digest },
+});
+/** Append or verify one exact completed assistant projection in the caller's PostgreSQL transaction. */
+export const appendCompletedSessionEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const session = yield* lockSession(input.sessionId);
+    const rows = yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
+    `;
+    const existing = rows[0];
+    const payload = completedPayload(input);
+    if (existing !== undefined) {
+        if (existing.parent_id !== input.parentId ||
+            !entryPayloadEquivalence(toEntry(existing), payload)) {
+            return yield* Session.SessionConflict.make({
+                reason: "entry-id-reused",
+                message: `Session entry id ${input.entryId} does not match the completed response`,
+            });
+        }
+        const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
+        if (conflict !== undefined)
+            return yield* conflict;
+        return toEntry(existing);
+    }
+    if (session.leaf_id !== input.parentId) {
+        return yield* Session.SessionConflict.make({
+            reason: "stale-leaf",
+            message: `Expected Session leaf ${String(input.parentId)} but found ${String(session.leaf_id)}`,
+        });
+    }
+    yield* insertEntry({
+        sessionId: input.sessionId,
+        id: input.entryId,
+        parentId: input.parentId,
+        seq: Number(session.next_seq),
+        tag: "ModelResponse",
+        payload: payload,
+    });
+    yield* advanceSession({
+        sessionId: input.sessionId,
+        leafId: input.entryId,
+        nextSeq: Number(session.next_seq) + 1,
+    });
+    return { ...payload, id: input.entryId, parentId: input.parentId };
+});
+/** Verify an exact completed assistant projection in the caller's PostgreSQL transaction. */
+export const verifyCompletedSessionEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const session = yield* lockSession(input.sessionId);
+    const rows = yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
+    `;
+    const existing = rows[0];
+    if (existing === undefined ||
+        existing.parent_id !== input.parentId ||
+        !entryPayloadEquivalence(toEntry(existing), completedPayload(input))) {
+        return yield* Session.SessionConflict.make({
+            reason: "entry-id-reused",
+            message: `Session entry id ${input.entryId} does not match the completed response`,
+        });
+    }
+    const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
+    if (conflict !== undefined)
+        return yield* conflict;
+});
+/** Append or verify one exact nonempty interrupted assistant projection in the caller's transaction. */
+export const appendInterruptedSessionEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const session = yield* lockSession(input.sessionId);
+    const rows = yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
+    `;
+    const existing = rows[0];
+    const payload = interruptedPayload(input);
+    if (existing !== undefined) {
+        if (existing.parent_id !== input.parentId ||
+            !entryPayloadEquivalence(toEntry(existing), payload)) {
+            return yield* Session.SessionConflict.make({
+                reason: "entry-id-reused",
+                message: `Session entry id ${input.entryId} was reused with different interrupted response content`,
+            });
+        }
+        const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
+        if (conflict !== undefined)
+            return yield* conflict;
+        return toEntry(existing);
+    }
+    if (session.leaf_id !== input.parentId) {
+        return yield* Session.SessionConflict.make({
+            reason: "stale-leaf",
+            message: `Expected Session leaf ${String(input.parentId)} but found ${String(session.leaf_id)}`,
+        });
+    }
+    yield* insertEntry({
+        sessionId: input.sessionId,
+        id: input.entryId,
+        parentId: input.parentId,
+        seq: Number(session.next_seq),
+        tag: "ModelResponse",
+        payload: payload,
+    });
+    yield* advanceSession({
+        sessionId: input.sessionId,
+        leafId: input.entryId,
+        nextSeq: Number(session.next_seq) + 1,
+    });
+    return { ...payload, id: input.entryId, parentId: input.parentId };
+});
+export const verifyInterruptedSessionEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const session = yield* lockSession(input.sessionId);
+    const rows = yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
+    `;
+    const existing = rows[0];
+    if (existing === undefined ||
+        existing.parent_id !== input.parentId ||
+        !entryPayloadEquivalence(toEntry(existing), interruptedPayload(input))) {
+        return yield* Session.SessionConflict.make({
+            reason: "entry-id-reused",
+            message: `Session entry id ${input.entryId} does not match the interrupted response`,
+        });
+    }
+    const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
+    if (conflict !== undefined)
+        return yield* conflict;
+});
+/** Append or verify one exact handoff projection in the caller's PostgreSQL transaction. */
+export const appendHandoffSessionEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const session = yield* lockSession(input.sessionId);
+    const rows = yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
+    `;
+    const existing = rows[0];
+    const payload = handoffPayload(input);
+    if (existing !== undefined) {
+        if (existing.parent_id !== input.parentId ||
+            !entryPayloadEquivalence(toEntry(existing), payload)) {
+            return yield* Session.SessionConflict.make({
+                reason: "entry-id-reused",
+                message: `Session entry id ${input.entryId} does not match the handoff projection`,
+            });
+        }
+        const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
+        if (conflict !== undefined)
+            return yield* conflict;
+        return toEntry(existing);
+    }
+    if (session.leaf_id !== input.parentId) {
+        return yield* Session.SessionConflict.make({
+            reason: "stale-leaf",
+            message: `Expected Session leaf ${String(input.parentId)} but found ${String(session.leaf_id)}`,
+        });
+    }
+    yield* insertEntry({
+        sessionId: input.sessionId,
+        id: input.entryId,
+        parentId: input.parentId,
+        seq: Number(session.next_seq),
+        tag: "Handoff",
+        payload,
+    });
+    yield* advanceSession({
+        sessionId: input.sessionId,
+        leafId: input.entryId,
+        nextSeq: Number(session.next_seq) + 1,
+    });
+    return { ...payload, id: input.entryId, parentId: input.parentId };
+});
+export const verifyHandoffSessionEntry = (input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const session = yield* lockSession(input.sessionId);
+    const rows = yield* sql `
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
+    `;
+    const existing = rows[0];
+    if (existing === undefined ||
+        existing.parent_id !== input.parentId ||
+        !entryPayloadEquivalence(toEntry(existing), handoffPayload(input))) {
+        return yield* Session.SessionConflict.make({
+            reason: "entry-id-reused",
+            message: `Session entry id ${input.entryId} does not match the handoff projection`,
+        });
+    }
+    const conflict = requireActive(yield* loadEntries(input.sessionId), session.leaf_id, input.entryId);
+    if (conflict !== undefined)
+        return yield* conflict;
+});
+const mapSessionError = (effect) => Effect.mapError(effect, (error) => Schema.is(Session.SessionConflict)(error) || Schema.is(Session.SessionStoreError)(error)
+    ? error
+    : storeError(String(error)));
+const mapReadError = (effect) => Effect.mapError(effect, (error) => (Schema.is(Session.SessionStoreError)(error) ? error : storeError(String(error))));
+/** Dialect-native durable PostgreSQL Session authority bound to one session identity. */
+export const makePostgresSessionStore = (options) => {
+    const { sessionId, run, runNoTxn } = options;
+    const append = (entry, appendOptions) => Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        const session = yield* lockSession(sessionId);
+        if (appendOptions?.id !== undefined) {
+            const rows = yield* sql `
+          SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+          WHERE session_id = ${sessionId} AND entry_id = ${appendOptions.id}
+        `;
+            const existing = rows[0];
+            if (existing !== undefined) {
+                const persisted = toEntry(existing);
+                if (!appendMatches(persisted, entry, appendOptions.expectedLeafId)) {
+                    return yield* Session.SessionConflict.make({
+                        reason: "entry-id-reused",
+                        message: `Session entry id ${appendOptions.id} was reused with different parent or content`,
+                    });
+                }
+                const conflict = requireActive(yield* loadEntries(sessionId), session.leaf_id, persisted.id);
+                if (conflict !== undefined)
+                    return yield* conflict;
+                return persisted;
+            }
+        }
+        if (appendOptions?.expectedLeafId !== undefined && appendOptions.expectedLeafId !== session.leaf_id) {
+            return yield* Session.SessionConflict.make({
+                reason: "stale-leaf",
+                message: `Expected Session leaf ${String(appendOptions.expectedLeafId)} but found ${String(session.leaf_id)}`,
+            });
+        }
+        let generatedSequence = Number(session.next_seq);
+        if (appendOptions?.id === undefined) {
+            while (true) {
+                const collision = yield* sql `
+            SELECT entry_id FROM baton_session_entries
+            WHERE session_id = ${sessionId} AND entry_id = ${String(generatedSequence)}
+          `;
+                if (collision[0] === undefined)
+                    break;
+                generatedSequence += 1;
+            }
+        }
+        const id = appendOptions?.id ?? String(generatedSequence);
+        yield* insertEntry({
+            sessionId,
+            id,
+            parentId: session.leaf_id,
+            seq: Number(session.next_seq),
+            tag: entry._tag,
+            payload: entry,
+        });
+        yield* advanceSession({
+            sessionId,
+            leafId: id,
+            nextSeq: appendOptions?.id === undefined ? generatedSequence + 1 : Number(session.next_seq) + 1,
+            ...(appendOptions?.ownerToken === undefined ? {} : { ownerToken: appendOptions.ownerToken }),
+        });
+        return { ...entry, id, parentId: session.leaf_id };
+    });
+    const appendCheckpoint = (prepared) => Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        const session = yield* lockSession(sessionId);
+        const rows = yield* sql `
+        SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+        WHERE session_id = ${sessionId} AND entry_id = ${prepared.id}
+      `;
+        const existing = rows[0];
+        if (existing !== undefined) {
+            const entry = toEntry(existing);
+            if (entry._tag !== "Compaction" || !Session.checkpointMatches(entry, prepared)) {
+                return yield* Session.SessionConflict.make({
+                    reason: "checkpoint-id-reused",
+                    message: `Session checkpoint id ${prepared.id} was reused with different content`,
+                });
+            }
+            const conflict = requireActive(yield* loadEntries(sessionId), session.leaf_id, prepared.id, "checkpoint-not-on-active-path");
+            if (conflict !== undefined)
+                return yield* conflict;
+            return {
+                _tag: "AlreadyPresent",
+                checkpoint: entry,
+                leafId: session.leaf_id ?? entry.id,
+            };
+        }
+        if (prepared.compactionCommit !== undefined && prepared.compactionCommit.checkpointId !== prepared.id) {
+            return yield* Session.SessionConflict.make({
+                reason: "checkpoint-id-reused",
+                message: `Compaction commit checkpoint id ${prepared.compactionCommit.checkpointId} does not match ${prepared.id}`,
+            });
+        }
+        if (prepared.parentId !== session.leaf_id) {
+            return yield* Session.SessionConflict.make({
+                reason: "stale-leaf",
+                message: `Expected Session leaf ${String(prepared.parentId)} but found ${String(session.leaf_id)}`,
+            });
+        }
+        const checkpoint = {
+            _tag: "Compaction",
+            id: prepared.id,
+            parentId: prepared.parentId,
+            projectedHistory: prepared.projectedHistory,
+            telemetry: prepared.telemetry,
+            ...(prepared.compactionCommit === undefined ? {} : { compactionCommit: prepared.compactionCommit }),
+            ...(prepared.summary === undefined ? {} : { summary: prepared.summary }),
+        };
+        yield* insertEntry({
+            sessionId,
+            id: checkpoint.id,
+            parentId: checkpoint.parentId,
+            seq: Number(session.next_seq),
+            tag: "Compaction",
+            payload: checkpoint,
+        });
+        yield* advanceSession({
+            sessionId,
+            leafId: checkpoint.id,
+            nextSeq: Number(session.next_seq) + 1,
+            ...(prepared.ownerToken === undefined ? {} : { ownerToken: prepared.ownerToken }),
+        });
+        return { _tag: "Appended", checkpoint, leafId: checkpoint.id };
+    });
+    return Session.SessionStore.of({
+        reserveEntryId: run(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            const session = yield* lockSession(sessionId);
+            let sequence = Number(session.next_seq);
+            while (true) {
+                const collision = yield* sql `
+            SELECT entry_id FROM baton_session_entries
+            WHERE session_id = ${sessionId} AND entry_id = ${String(sequence)}
+          `;
+                if (collision[0] === undefined)
+                    break;
+                sequence += 1;
+            }
+            yield* advanceSession({ sessionId, leafId: session.leaf_id, nextSeq: sequence + 1 });
+            return String(sequence);
+        })).pipe(mapReadError),
+        append: (entry, appendOptions) => run(append(entry, appendOptions)).pipe(mapSessionError),
+        appendCheckpoint: (prepared) => run(appendCheckpoint(prepared)).pipe(mapSessionError),
+        path: (leaf) => runNoTxn(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            const sessions = yield* sql `
+            SELECT leaf_id, next_seq, owner_token FROM baton_sessions WHERE session_id = ${sessionId}
+          `;
+            return { target: leaf ?? sessions[0]?.leaf_id ?? null, rows: yield* loadEntries(sessionId) };
+        }).pipe(Effect.flatMap(({ rows, target }) => {
+            const path = pathFromRows(rows, target);
+            return Schema.is(Session.SessionStoreError)(path) ? path : Effect.succeed(path);
+        }))).pipe(mapReadError),
+        setLeaf: (id) => run(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            yield* lockSession(sessionId);
+            if (id !== null) {
+                const rows = yield* sql `
+              SELECT entry_id FROM baton_session_entries WHERE session_id = ${sessionId} AND entry_id = ${id}
+            `;
+                if (rows[0] === undefined)
+                    return yield* storeError(`Session entry ${id} does not exist`);
+            }
+            yield* sql `UPDATE baton_sessions SET leaf_id = ${id}, updated_at = NOW() WHERE session_id = ${sessionId}`;
+        })).pipe(mapReadError),
+        leaf: Effect.orDie(runNoTxn(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            const rows = yield* sql `
+            SELECT leaf_id, next_seq, owner_token FROM baton_sessions WHERE session_id = ${sessionId}
+          `;
+            return rows[0]?.leaf_id ?? null;
+        }))),
+    });
+};

package/dist/postgres/store-admit.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { AddressNotFound, IdempotencyConflict, RunIdConflict, TreePolicyInvalid } from "tenetkit/runtime/driver/errors";
+import type { PinnedExecutable } from "tenetkit/runtime/driver/executable-manifest";
+import type { AdmitSendInput } from "tenetkit/runtime/driver/run-store";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+/** Exact addressed admission for the PostgreSQL store. */
+export declare const admitSend: {
+    (addressBindings: ReadonlyMap<string, PinnedExecutable>, nextId: (prefix: string) => Effect.Effect<string>, input: AdmitSendInput): (hub: EventHub) => Effect.Effect<{
+        runId: string;
+        messageId: string;
+        acceptedSequence: number;
+        duplicate: boolean;
+    }, AddressNotFound | IdempotencyConflict | RunIdConflict | TreePolicyInvalid | import("tenetkit/runtime/driver/errors").RuntimeUnavailable | import("effect/unstable/sql/SqlError").SqlError, SqlClient.SqlClient>;
+    (hub: EventHub, addressBindings: ReadonlyMap<string, PinnedExecutable>, nextId: (prefix: string) => Effect.Effect<string>, input: AdmitSendInput): Effect.Effect<{
+        runId: string;
+        messageId: string;
+        acceptedSequence: number;
+        duplicate: boolean;
+    }, AddressNotFound | IdempotencyConflict | RunIdConflict | TreePolicyInvalid | import("tenetkit/runtime/driver/errors").RuntimeUnavailable | import("effect/unstable/sql/SqlError").SqlError, SqlClient.SqlClient>;
+};

package/dist/postgres/store-admit.js

@@ -0,0 +1,87 @@
+import { Effect, Function } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+import { AddressNotFound, IdempotencyConflict, RunIdConflict, TreePolicyInvalid } from "tenetkit/runtime/driver/errors";
+import { equals } from "tenetkit/runtime/driver/executable-manifest";
+import { rootDigest } from "tenetkit/runtime/driver/memory/digest";
+import { appendEvent, enqueueLane, insertRun, loadRun } from "./pg-helpers.js";
+import { associateRegistrations, persistRegistrations } from "tenetkit/runtime/driver/sql/executable-registrations";
+import { decodePinnedEffect, decodeStoredPinnedEffect } from "tenetkit/runtime/driver/sql/codecs";
+import { normalize as normalizeTreePolicy } from "tenetkit/runtime/driver/tree-policy";
+/** Exact addressed admission for the PostgreSQL store. */
+export const admitSend = Function.dual(4, (hub, addressBindings, nextId, input) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const bound = addressBindings.get(input.message.to);
+    if (bound === undefined)
+        return yield* AddressNotFound.make({ address: input.message.to });
+    const admitted = yield* decodePinnedEffect({
+        ref: input.executableRef,
+        manifest: input.executableManifest,
+    });
+    const binding = yield* decodePinnedEffect(bound);
+    if (!equals(binding, admitted)) {
+        return yield* AddressNotFound.make({ address: input.message.to });
+    }
+    yield* sql `SELECT pg_advisory_xact_lock(hashtext(${`admit:${input.message.to}:${input.message.sessionId}:${input.message.idempotencyKey}`}))`;
+    if (input.runId !== undefined) {
+        yield* sql `SELECT pg_advisory_xact_lock(hashtext(${`run:${input.runId}`}))`;
+    }
+    const treePolicy = yield* normalizeTreePolicy(input.treePolicy);
+    const digest = rootDigest(input.message, treePolicy);
+    const existing = yield* sql `
+      SELECT * FROM baton_runs
+      WHERE address = ${input.message.to}
+        AND session_id = ${input.message.sessionId}
+        AND idempotency_key = ${input.message.idempotencyKey}
+    `;
+    const prior = existing[0];
+    if (prior !== undefined) {
+        if (input.runId !== undefined && input.runId !== prior.run_id) {
+            return yield* RunIdConflict.make({ runId: input.runId, existingRunId: prior.run_id });
+        }
+        const priorExecutable = yield* decodeStoredPinnedEffect(prior.executable_ref_json, prior.executable_manifest_json);
+        if (prior.message_digest !== digest || !equals(priorExecutable, admitted)) {
+            return yield* IdempotencyConflict.make({
+                address: input.message.to,
+                sessionId: input.message.sessionId,
+                idempotencyKey: input.message.idempotencyKey,
+                existingRunId: prior.run_id,
+            });
+        }
+        return {
+            runId: prior.run_id,
+            messageId: prior.message_id,
+            acceptedSequence: Number(prior.accepted_sequence),
+            duplicate: true,
+        };
+    }
+    if (input.runId !== undefined) {
+        const byId = yield* sql `SELECT * FROM baton_runs WHERE run_id = ${input.runId}`;
+        if (byId[0] !== undefined)
+            return yield* RunIdConflict.make({ runId: input.runId, existingRunId: byId[0].run_id });
+    }
+    const runId = input.runId ?? (yield* nextId("run"));
+    const enqueued = yield* enqueueLane(input.message.to, input.message.sessionId, runId);
+    yield* insertRun({
+        runId,
+        status: "queued",
+        message: input.message,
+        digest,
+        executableRef: input.executableRef,
+        executableManifest: input.executableManifest,
+        rootRunId: runId,
+        depth: 0,
+        treePolicy,
+        acceptedSequence: enqueued.acceptedSequence,
+    });
+    yield* sql `SELECT pg_advisory_xact_lock(hashtext('tenetkit:executable-registrations'))`;
+    yield* persistRegistrations(input.registrations);
+    yield* associateRegistrations(runId, input.registrations);
+    const loaded = (yield* loadRun(runId));
+    yield* appendEvent(hub, loaded, { _tag: "RunAccepted", messageId: input.message.id, address: input.message.to }, "queued");
+    return {
+        runId,
+        messageId: input.message.id,
+        acceptedSequence: enqueued.acceptedSequence,
+        duplicate: false,
+    };
+}));

package/dist/postgres/store-cancel.d.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import type { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { RunNotFound, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+export declare const deferCancelledFanOutParent: {
+    (runId: string): (sql: SqlClient.SqlClient) => Effect.Effect<boolean, SqlError, SqlClient.SqlClient>;
+    (sql: SqlClient.SqlClient, runId: string): Effect.Effect<boolean, SqlError, SqlClient.SqlClient>;
+};
+export declare const makeCancelRun: (input: {
+    readonly sql: SqlClient.SqlClient;
+    readonly hub: EventHub;
+}) => (runId: string, reason: string | undefined) => Effect.Effect<void, RunNotFound | RuntimeUnavailable | SqlError, SqlClient.SqlClient | PgClient.PgClient>;

package/dist/postgres/store-cancel.js

@@ -0,0 +1,73 @@
+import { Effect, Function } from "effect";
+import { RunNotFound, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import { isTerminal } from "tenetkit/runtime/driver/run";
+import { hasUnsettledChild } from "tenetkit/runtime/driver/sql/store-child-settlement";
+import { afterTerminal, appendEvent, loadRun, settleParent } from "./pg-helpers.js";
+import { cancelOwnedFanOuts } from "./store-fan-out.js";
+import { reconcileProgramCancellation } from "tenetkit/runtime/driver/sql/store-program";
+export const deferCancelledFanOutParent = Function.dual(2, (sql, runId) => Effect.gen(function* () {
+    const running = yield* sql `
+      SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
+    `;
+    if (running.length === 0 && !(yield* hasUnsettledChild(runId)))
+        return false;
+    yield* sql `UPDATE baton_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${runId}`;
+    return true;
+}));
+export const makeCancelRun = (input) => {
+    const cancelRun = (runId, reason) => Effect.gen(function* () {
+        let current = yield* loadRun(runId).pipe(Effect.flatMap((run) => (run === undefined ? RunNotFound.make({ runId }) : Effect.succeed(run))));
+        const terminal = isTerminal(current.status);
+        const needsResolution = current.status === "needs-resolution";
+        const executing = current.ownerWorkerId !== undefined && (current.status === "running" || current.status === "cancelling");
+        if (!terminal && !current.cancellationRequested) {
+            yield* appendEvent(input.hub, current, { _tag: "RunCancellationRequested", ...(reason === undefined ? {} : { reason }) }, needsResolution ? "needs-resolution" : "cancelling");
+            current = (yield* loadRun(runId));
+        }
+        if (!terminal)
+            yield* reconcileProgramCancellation(runId, reason ?? current.cancelReason);
+        yield* input.sql `
+        UPDATE baton_run_waits SET status = 'cancelled', closed_at = NOW()
+        WHERE run_id = ${runId} AND status = 'open'
+      `;
+        const linked = yield* input.sql `
+        SELECT l.child_run_id FROM baton_run_links l
+        LEFT JOIN baton_fan_out_members m ON m.child_run_id = l.child_run_id
+        WHERE l.parent_run_id = ${runId} AND m.child_run_id IS NULL
+        ORDER BY l.child_run_id ASC
+      `;
+        for (const link of linked) {
+            const child = yield* loadRun(link.child_run_id);
+            if (child !== undefined && !isTerminal(child.status))
+                yield* cancelRun(child.runId, reason ?? "parent cancelled");
+        }
+        if (linked.length > 0)
+            current = (yield* loadRun(runId));
+        const owned = yield* cancelOwnedFanOuts(input.sql, runId);
+        for (const childRunId of owned) {
+            const child = yield* loadRun(childRunId);
+            if (child !== undefined && !isTerminal(child.status))
+                yield* cancelRun(child.runId, reason ?? "parent cancelled");
+        }
+        if (owned.length > 0)
+            current = (yield* loadRun(runId));
+        if (terminal)
+            return;
+        if (executing)
+            return;
+        if (isTerminal(current.status))
+            return;
+        const running = yield* input.sql `
+        SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
+      `;
+        if (running.length > 0)
+            return;
+        if (yield* hasUnsettledChild(runId))
+            return;
+        const event = yield* appendEvent(input.hub, current, { _tag: "RunCancelled", ...(reason === undefined ? {} : { reason }) }, "cancelled");
+        const settled = (yield* loadRun(runId));
+        yield* settleParent(input.hub, settled, event.eventId);
+        yield* afterTerminal(input.hub, settled);
+    });
+    return cancelRun;
+};

package/dist/postgres/store-claims.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import type { PgClient } from "@effect/sql-pg";
+import { SqlClient } from "effect/unstable/sql";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
+import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
+import { type Interface as ClaimsInterface } from "tenetkit/runtime/driver/sql/run-claims";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+type SqlR = SqlClient.SqlClient | PgClient.PgClient;
+export type RunFn = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | RuntimeUnavailable>;
+export declare const makePostgresClaims: (input: {
+    readonly sql: SqlClient.SqlClient;
+    readonly hub: EventHub;
+    readonly run: RunFn;
+    readonly cancelRun: (runId: string, reason: string | undefined) => Effect.Effect<void, RunNotFound | RunTerminal | RuntimeUnavailable | SqlError, SqlR>;
+}) => ClaimsInterface;
+export {};