@tenetkit/pg 0.30.0 → 0.32.0

package/dist/postgres/run-schema.js

@@ -1,9 +1,13 @@
-import { DateTime, Effect, Layer, Redacted } from "effect";
+import { Cause, DateTime, Effect, Layer, Redacted } from "effect";
 import { Migrator, SqlClient } from "effect/unstable/sql";
 import { PgClient } from "@effect/sql-pg";
 import { SchemaChecksumMismatch, SchemaDirty, SchemaMigrationFailed, SchemaUpgradeRequired, SchemaVersionUnsupported, } from "tenetkit/runtime/driver/sql/errors";
 import { mapSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
-import { MIGRATIONS_TABLE, SCHEMA_META_TABLE, SCHEMA_STATEMENTS, SCHEMA_VERSION, schemaChecksum } from "./schema.js";
+import { EXTERNAL_CHILD_STATEMENTS, MIGRATIONS_TABLE, SCHEMA_META_TABLE, SCHEMA_STATEMENTS, SCHEMA_VERSION, V7_SCHEMA_CHECKSUM, V7_SCHEMA_STATEMENTS, schemaChecksum, } from "./schema.js";
+const migrationFailure = (source, fallback) => (error) => SchemaMigrationFailed.make({
+    source,
+    message: typeof error === "object" && error !== null && "message" in error ? String(error.message) : fallback,
+});
 const readMeta = (source) => mapSqlError(Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const exists = yield* sql `
@@ -25,22 +29,61 @@ const readMeta = (source) => mapSqlError(Effect.gen(function* () {
     source,
     message: "message" in error ? String(error.message) : "schema meta read failed",
 })));
-const migrationEffect = Effect.gen(function* () {
+const verifyMigrationIdentity = (source, version) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
-    for (const statement of SCHEMA_STATEMENTS)
+    const migrations = yield* sql `
+      SELECT migration_id, name FROM ${sql(MIGRATIONS_TABLE)} ORDER BY migration_id
+    `;
+    const expected = version === 7
+        ? [[1, "baton_runtime"]]
+        : [
+            [1, "baton_runtime"],
+            [2, "external_child_placements"],
+        ];
+    if (migrations.length !== expected.length ||
+        migrations.some((migration, index) => Number(migration.migration_id) !== expected[index]?.[0] || migration.name !== expected[index]?.[1])) {
+        return yield* SchemaMigrationFailed.make({ source, message: `version ${version} migration identity mismatch` });
+    }
+}).pipe(Effect.mapError(migrationFailure(source, "migration identity read failed")));
+const baselineMigration = Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    for (const statement of V7_SCHEMA_STATEMENTS)
         yield* sql.unsafe(statement);
     const now = yield* DateTime.nowAsDate;
     yield* sql `
     INSERT INTO ${sql(SCHEMA_META_TABLE)} (id, version, checksum, dirty, applied_at)
-    VALUES (1, ${SCHEMA_VERSION}, ${schemaChecksum()}, FALSE, ${now})
+    VALUES (1, 7, ${V7_SCHEMA_CHECKSUM}, FALSE, ${now})
   `;
 });
+const externalChildMigration = Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `UPDATE ${sql(SCHEMA_META_TABLE)} SET dirty = TRUE WHERE id = 1`;
+    for (const statement of EXTERNAL_CHILD_STATEMENTS) {
+        yield* sql.unsafe(statement.replaceAll(" IF NOT EXISTS", ""));
+    }
+    const now = yield* DateTime.nowAsDate;
+    yield* sql `UPDATE ${sql(SCHEMA_META_TABLE)}
+    SET version = ${SCHEMA_VERSION}, checksum = ${schemaChecksum()}, dirty = FALSE, applied_at = ${now}
+    WHERE id = 1`;
+});
+const runMigrations = (source) => {
+    const migrate = Migrator.make({});
+    return migrate({
+        loader: Migrator.fromRecord({
+            "0001_baton_runtime": baselineMigration,
+            "0002_external_child_placements": externalChildMigration,
+        }),
+        table: MIGRATIONS_TABLE,
+    }).pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause)
+        ? Effect.interrupt
+        : SchemaMigrationFailed.make({ source, message: Cause.pretty(cause) || "migration failed" })));
+};
 export const plan = (source) => Effect.map(readMeta(source), (meta) => ({
     current: meta.version,
     required: SCHEMA_VERSION,
     checksum: schemaChecksum(),
-    statements: meta.present ? [] : SCHEMA_STATEMENTS,
-    upgradeRequired: !meta.present,
+    statements: meta.present ? (meta.version === 7 ? EXTERNAL_CHILD_STATEMENTS : []) : SCHEMA_STATEMENTS,
+    upgradeRequired: meta.version < SCHEMA_VERSION,
 }));
 export const check = (source) => Effect.gen(function* () {
     const meta = yield* readMeta(source);
@@ -55,11 +98,17 @@ export const check = (source) => Effect.gen(function* () {
     if (meta.version !== SCHEMA_VERSION || meta.checksum !== expected) {
         return yield* SchemaChecksumMismatch.make({ source, expected, actual: meta.checksum });
     }
+    yield* verifyMigrationIdentity(source, SCHEMA_VERSION);
 });
 export const apply = (source) => Effect.gen(function* () {
     const meta = yield* readMeta(source);
-    if (meta.present)
+    if (meta.present) {
+        if (meta.dirty || meta.version !== 7 || meta.checksum !== V7_SCHEMA_CHECKSUM)
+            return yield* check(source);
+        yield* verifyMigrationIdentity(source, 7);
+        yield* runMigrations(source);
         return yield* check(source);
+    }
     const sql = yield* SqlClient.SqlClient;
     const existing = yield* sql `
       SELECT COUNT(*) AS present FROM information_schema.tables
@@ -71,14 +120,7 @@ export const apply = (source) => Effect.gen(function* () {
             message: "cannot create the baseline over an existing TenetKit schema",
         });
     }
-    const runMigrations = Migrator.make({});
-    yield* runMigrations({
-        loader: Migrator.fromRecord({ "0001_baton_runtime": migrationEffect }),
-        table: MIGRATIONS_TABLE,
-    }).pipe(Effect.mapError((error) => SchemaMigrationFailed.make({
-        source,
-        message: "message" in error ? String(error.message) : "migration failed",
-    })));
+    yield* runMigrations(source);
     yield* check(source).pipe(Effect.catchTag("tenetkit/runtime/SchemaUpgradeRequired", (error) => SchemaMigrationFailed.make({ source, message: `schema absent after apply: ${error.current}` })));
 });
 export const markDirty = (source) => mapSqlError(Effect.gen(function* () {

package/dist/postgres/schema.d.ts

@@ -1,6 +1,9 @@
-export declare const SCHEMA_VERSION = 7;
+export declare const SCHEMA_VERSION = 8;
+export declare const V7_SCHEMA_CHECKSUM = "4d86018b3453e9757e05694ce981fc486a15a00ebb36874b49821f6289e6d495";
 export declare const SCHEMA_META_TABLE = "baton_schema_meta";
 export declare const MIGRATIONS_TABLE = "baton_sql_migrations";
 export declare const NOTIFY_CHANNEL = "baton_run_events";
+export declare const V7_SCHEMA_STATEMENTS: ReadonlyArray<string>;
+export declare const EXTERNAL_CHILD_STATEMENTS: ReadonlyArray<string>;
 export declare const SCHEMA_STATEMENTS: ReadonlyArray<string>;
 export declare const schemaChecksum: () => string;

package/dist/postgres/schema.js

@@ -1,8 +1,9 @@
-export const SCHEMA_VERSION = 7;
+export const SCHEMA_VERSION = 8;
+export const V7_SCHEMA_CHECKSUM = "4d86018b3453e9757e05694ce981fc486a15a00ebb36874b49821f6289e6d495";
 export const SCHEMA_META_TABLE = "baton_schema_meta";
 export const MIGRATIONS_TABLE = "baton_sql_migrations";
 export const NOTIFY_CHANNEL = "baton_run_events";
-export const SCHEMA_STATEMENTS = [
+export const V7_SCHEMA_STATEMENTS = [
     `CREATE TABLE IF NOT EXISTS baton_schema_meta (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   version INTEGER NOT NULL,
@@ -265,6 +266,33 @@ export const SCHEMA_STATEMENTS = [
     `CREATE UNIQUE INDEX IF NOT EXISTS baton_session_entries_seq_idx ON baton_session_entries(session_id, seq)`,
     `CREATE INDEX IF NOT EXISTS baton_session_entries_parent_idx ON baton_session_entries(session_id, parent_id)`,
 ];
+export const EXTERNAL_CHILD_STATEMENTS = [
+    `CREATE TABLE IF NOT EXISTS baton_external_child_placements (
+  placement_id TEXT PRIMARY KEY,
+  parent_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  partition TEXT NOT NULL,
+  external_run_id TEXT NOT NULL,
+  invocation_id TEXT NOT NULL,
+  request_digest TEXT NOT NULL,
+  executable_digest TEXT NOT NULL,
+  wait_id TEXT,
+  suspension_identity TEXT,
+  acknowledged BOOLEAN NOT NULL DEFAULT FALSE,
+  cancel_requested BOOLEAN NOT NULL DEFAULT FALSE,
+  settlement_id TEXT,
+  outcome_json TEXT,
+  outcome_event_id TEXT,
+  created_at TIMESTAMPTZ NOT NULL,
+  settled_at TIMESTAMPTZ,
+  UNIQUE (partition, external_run_id),
+  UNIQUE (parent_run_id, invocation_id),
+  CHECK ((settlement_id IS NULL AND outcome_json IS NULL AND outcome_event_id IS NULL AND settled_at IS NULL)
+    OR (settlement_id IS NOT NULL AND outcome_json IS NOT NULL AND outcome_event_id IS NOT NULL AND settled_at IS NOT NULL))
+)`,
+    `CREATE INDEX IF NOT EXISTS baton_external_child_placements_parent_idx
+    ON baton_external_child_placements(parent_run_id, settlement_id, created_at)`,
+];
+export const SCHEMA_STATEMENTS = [...V7_SCHEMA_STATEMENTS, ...EXTERNAL_CHILD_STATEMENTS];
 export const schemaChecksum = () => {
     const hasher = new Bun.CryptoHasher("sha256");
     hasher.update(SCHEMA_STATEMENTS.join("\n"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@effect/sql-pg": "4.0.0-rc.109",
-    "tenetkit": "0.30.0"
+    "tenetkit": "0.32.0"
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.109",