@xemahq/biome-database-nest 7.3.0 → 8.0.0

package/dist/lib/org-quiesce/org-write-fence-coverage.d.ts

@@ -0,0 +1,18 @@
+import type { OrgWriteFenceTable } from './org-write-fence-triggers';
+import type { OrgErasureGraph } from '../org-erasure-coverage/org-erasure-graph';
+export interface OrgWriteFenceExemption {
+    readonly table: string;
+    readonly reason: string;
+}
+export interface OrgWriteFenceCoverageOptions {
+    readonly orgField?: string;
+    readonly exemptModels?: readonly string[];
+    readonly tableOfModel: (model: string) => string;
+    readonly extraTables?: readonly string[];
+}
+export declare class OrgWriteFenceCoverageError extends Error {
+    readonly problems: readonly string[];
+    constructor(problems: readonly string[]);
+}
+export declare function assertOrgWriteFenceCoversErasureGraph(graph: OrgErasureGraph, orgWriteFenceTables: ReadonlyArray<OrgWriteFenceTable>, exempt: ReadonlyArray<OrgWriteFenceExemption>, options: OrgWriteFenceCoverageOptions): void;
+//# sourceMappingURL=org-write-fence-coverage.d.ts.map

package/dist/lib/org-quiesce/org-write-fence-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence-coverage.d.ts","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence-coverage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAGjF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,4BAA4B;IAE3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAK1C,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAMjD,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAGD,qBAAa,0BAA2B,SAAQ,KAAK;aAChB,QAAQ,EAAE,SAAS,MAAM,EAAE;gBAA3B,QAAQ,EAAE,SAAS,MAAM,EAAE;CAM/D;AAeD,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,eAAe,EACtB,mBAAmB,EAAE,aAAa,CAAC,kBAAkB,CAAC,EACtD,MAAM,EAAE,aAAa,CAAC,sBAAsB,CAAC,EAC7C,OAAO,EAAE,4BAA4B,GACpC,IAAI,CA4CN"}

package/dist/lib/org-quiesce/org-write-fence-coverage.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgWriteFenceCoverageError = void 0;
+exports.assertOrgWriteFenceCoversErasureGraph = assertOrgWriteFenceCoversErasureGraph;
+const tenant_isolation_extension_1 = require("../tenant-isolation/tenant-isolation.extension");
+class OrgWriteFenceCoverageError extends Error {
+    problems;
+    constructor(problems) {
+        super(`[org-write-fence] the org write fence does not cover the erasure graph: ${problems.join('; ')}.`);
+        this.problems = problems;
+        this.name = 'OrgWriteFenceCoverageError';
+    }
+}
+exports.OrgWriteFenceCoverageError = OrgWriteFenceCoverageError;
+function assertOrgWriteFenceCoversErasureGraph(graph, orgWriteFenceTables, exempt, options) {
+    const orgField = options.orgField ?? tenant_isolation_extension_1.DEFAULT_ORG_FIELD;
+    const skipped = new Set(options.exemptModels ?? []);
+    const declared = new Map(orgWriteFenceTables.map((entry) => [entry.table, entry]));
+    const exemptTables = new Set(exempt.map((entry) => entry.table));
+    const swept = Object.entries(graph.models)
+        .filter(([name, model]) => !skipped.has(name) && model.fields.includes(orgField))
+        .map(([name]) => ({ model: name, table: options.tableOfModel(name) }))
+        .sort((a, b) => (a.table < b.table ? -1 : 1));
+    const sweptTables = new Set(swept.map((entry) => entry.table));
+    const extras = new Set(options.extraTables ?? []);
+    const problems = [];
+    for (const entry of exempt) {
+        if (entry.reason.trim().length === 0) {
+            problems.push(`exempt table "${entry.table}" has no reason`);
+        }
+        if (declared.has(entry.table)) {
+            problems.push(`table "${entry.table}" is both declared and exempt`);
+        }
+    }
+    for (const { model, table } of swept) {
+        if (!declared.has(table) && !exemptTables.has(table)) {
+            problems.push(`swept model ${model} (table "${table}", org column "${orgField}") is neither fenced nor exempt`);
+        }
+    }
+    for (const entry of orgWriteFenceTables) {
+        if (entry.parent === undefined &&
+            !sweptTables.has(entry.table) &&
+            !extras.has(entry.table)) {
+            problems.push(`declared table "${entry.table}" is not a swept model's table, a parent-form table or an extra`);
+        }
+    }
+    if (problems.length > 0) {
+        throw new OrgWriteFenceCoverageError(problems);
+    }
+}
+//# sourceMappingURL=org-write-fence-coverage.js.map

package/dist/lib/org-quiesce/org-write-fence-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence-coverage.js","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence-coverage.ts"],"names":[],"mappings":"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"}

package/dist/lib/org-quiesce/org-write-fence-token.sql.d.ts

@@ -0,0 +1,2 @@
+export declare const ORG_WRITE_FENCE_TOKEN_SQL = "\nCREATE TABLE \"org_write_fence_rows\" (\n  \"org_id\" TEXT NOT NULL,\n  \"version\" BIGINT NOT NULL DEFAULT 0,\n  CONSTRAINT \"org_write_fence_rows_pkey\" PRIMARY KEY (\"org_id\")\n);\n\nCREATE FUNCTION xema_org_is_erasing(p_org text) RETURNS boolean\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nDECLARE\n  tag text := p_org || ':' || txid_current()::text;\nBEGIN\n  -- Already verified in THIS transaction (the tag carries the txid): skip\n  -- pg_locks. This cache is TRUSTED WITHOUT a pg_locks check, and a client can\n  -- set it: a client running arbitrary SQL in its own transaction can forge it\n  -- and write for a marked org. By design: the fence orders concurrent\n  -- APPLICATION writers against an erasure; it does not defend against such a\n  -- client, who could equally delete the marks or drop the triggers. The\n  -- declaration below, by contrast, is always checked against pg_locks.\n  IF current_setting('xema.org_erasure_verified', true) = tag THEN\n    RETURN true;\n  END IF;\n  -- Declared by xema_org_begin_erasure for this org and this transaction: trust\n  -- it only after ONE check against pg_locks that this backend really holds the\n  -- exclusive lock, and remember that check for the rest of the transaction.\n  IF current_setting('xema.org_erasure', true) = tag THEN\n    IF xema_org_holds_erasure_lock(p_org) THEN\n      PERFORM set_config('xema.org_erasure_verified', tag, true);\n      RETURN true;\n    END IF;\n    RETURN false;\n  END IF;\n  -- No declaration (a biome-owned eraser that took the lock itself, a stale or\n  -- foreign value): the lock in pg_locks is the authority, checked every time.\n  RETURN xema_org_holds_erasure_lock(p_org);\nEND\n$fn$;\n\nCREATE FUNCTION xema_org_begin_erasure(p_org text) RETURNS void\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  PERFORM xema_org_quiesce_mark(p_org);\n  PERFORM set_config('xema.org_erasure', p_org || ':' || txid_current()::text, true);\nEND\n$fn$;\n\nCREATE OR REPLACE FUNCTION xema_org_is_quiescing(p_org text) RETURNS boolean\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  -- The hot path: one shared advisory lock and one indexed read. The pg_locks\n  -- scan (which takes every lock-manager partition lock) runs ONLY for a\n  -- marked org, never per ordinary row write.\n  PERFORM pg_advisory_xact_lock_shared(xema_org_quiesce_lock_key(p_org));\n  -- A read-only transaction cannot write org rows, so it needs no token (and\n  -- cannot INSERT one: that would raise 25006).\n  IF current_setting('transaction_isolation') <> 'read committed'\n     AND current_setting('transaction_read_only') = 'off' THEN\n    INSERT INTO \"org_write_fence_rows\" (\"org_id\") VALUES (p_org) ON CONFLICT (\"org_id\") DO NOTHING;\n  END IF;\n  IF EXISTS (SELECT 1 FROM \"org_quiesce_marks\" AS m WHERE m.\"org_id\" = p_org) THEN\n    RETURN NOT xema_org_is_erasing(p_org);\n  END IF;\n  RETURN false;\nEND\n$fn$;\n\nCREATE OR REPLACE FUNCTION xema_org_quiesce_mark(p_org text) RETURNS void\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  PERFORM pg_advisory_xact_lock(xema_org_quiesce_lock_key(p_org));\n  INSERT INTO \"org_write_fence_rows\" (\"org_id\", \"version\") VALUES (p_org, 1)\n    ON CONFLICT (\"org_id\") DO UPDATE SET \"version\" = \"org_write_fence_rows\".\"version\" + 1;\n  INSERT INTO \"org_quiesce_marks\" (\"org_id\") VALUES (p_org) ON CONFLICT (\"org_id\") DO NOTHING;\nEND\n$fn$;\n";
+//# sourceMappingURL=org-write-fence-token.sql.d.ts.map

package/dist/lib/org-quiesce/org-write-fence-token.sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence-token.sql.d.ts","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence-token.sql.ts"],"names":[],"mappings":"AAmEA,eAAO,MAAM,yBAAyB,46GA2ErC,CAAC"}

package/dist/lib/org-quiesce/org-write-fence-token.sql.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORG_WRITE_FENCE_TOKEN_SQL = void 0;
+exports.ORG_WRITE_FENCE_TOKEN_SQL = `
+CREATE TABLE "org_write_fence_rows" (
+  "org_id" TEXT NOT NULL,
+  "version" BIGINT NOT NULL DEFAULT 0,
+  CONSTRAINT "org_write_fence_rows_pkey" PRIMARY KEY ("org_id")
+);
+
+CREATE FUNCTION xema_org_is_erasing(p_org text) RETURNS boolean
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+DECLARE
+  tag text := p_org || ':' || txid_current()::text;
+BEGIN
+  -- Already verified in THIS transaction (the tag carries the txid): skip
+  -- pg_locks. This cache is TRUSTED WITHOUT a pg_locks check, and a client can
+  -- set it: a client running arbitrary SQL in its own transaction can forge it
+  -- and write for a marked org. By design: the fence orders concurrent
+  -- APPLICATION writers against an erasure; it does not defend against such a
+  -- client, who could equally delete the marks or drop the triggers. The
+  -- declaration below, by contrast, is always checked against pg_locks.
+  IF current_setting('xema.org_erasure_verified', true) = tag THEN
+    RETURN true;
+  END IF;
+  -- Declared by xema_org_begin_erasure for this org and this transaction: trust
+  -- it only after ONE check against pg_locks that this backend really holds the
+  -- exclusive lock, and remember that check for the rest of the transaction.
+  IF current_setting('xema.org_erasure', true) = tag THEN
+    IF xema_org_holds_erasure_lock(p_org) THEN
+      PERFORM set_config('xema.org_erasure_verified', tag, true);
+      RETURN true;
+    END IF;
+    RETURN false;
+  END IF;
+  -- No declaration (a biome-owned eraser that took the lock itself, a stale or
+  -- foreign value): the lock in pg_locks is the authority, checked every time.
+  RETURN xema_org_holds_erasure_lock(p_org);
+END
+$fn$;
+
+CREATE FUNCTION xema_org_begin_erasure(p_org text) RETURNS void
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  PERFORM xema_org_quiesce_mark(p_org);
+  PERFORM set_config('xema.org_erasure', p_org || ':' || txid_current()::text, true);
+END
+$fn$;
+
+CREATE OR REPLACE FUNCTION xema_org_is_quiescing(p_org text) RETURNS boolean
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  -- The hot path: one shared advisory lock and one indexed read. The pg_locks
+  -- scan (which takes every lock-manager partition lock) runs ONLY for a
+  -- marked org, never per ordinary row write.
+  PERFORM pg_advisory_xact_lock_shared(xema_org_quiesce_lock_key(p_org));
+  -- A read-only transaction cannot write org rows, so it needs no token (and
+  -- cannot INSERT one: that would raise 25006).
+  IF current_setting('transaction_isolation') <> 'read committed'
+     AND current_setting('transaction_read_only') = 'off' THEN
+    INSERT INTO "org_write_fence_rows" ("org_id") VALUES (p_org) ON CONFLICT ("org_id") DO NOTHING;
+  END IF;
+  IF EXISTS (SELECT 1 FROM "org_quiesce_marks" AS m WHERE m."org_id" = p_org) THEN
+    RETURN NOT xema_org_is_erasing(p_org);
+  END IF;
+  RETURN false;
+END
+$fn$;
+
+CREATE OR REPLACE FUNCTION xema_org_quiesce_mark(p_org text) RETURNS void
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  PERFORM pg_advisory_xact_lock(xema_org_quiesce_lock_key(p_org));
+  INSERT INTO "org_write_fence_rows" ("org_id", "version") VALUES (p_org, 1)
+    ON CONFLICT ("org_id") DO UPDATE SET "version" = "org_write_fence_rows"."version" + 1;
+  INSERT INTO "org_quiesce_marks" ("org_id") VALUES (p_org) ON CONFLICT ("org_id") DO NOTHING;
+END
+$fn$;
+`;
+//# sourceMappingURL=org-write-fence-token.sql.js.map

package/dist/lib/org-quiesce/org-write-fence-token.sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence-token.sql.js","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence-token.sql.ts"],"names":[],"mappings":";;;AAmEa,QAAA,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ExC,CAAC"}

package/dist/lib/org-quiesce/org-write-fence-triggers.d.ts

@@ -0,0 +1,48 @@
+import type { AdvisoryLockClient } from '../advisory-lock';
+export declare const ORG_WRITE_FENCE_TRIGGER_NAME = "xema_org_write_fence";
+export declare const ORG_WRITE_FENCE_MOVE_TRIGGER_NAME = "xema_org_write_fence_move";
+export declare const ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME = "xema_org_write_fence_truncate";
+export type OrgWriteFenceEvents = 'insert' | 'all';
+export interface OrgWriteFenceColumnTable {
+    readonly events?: OrgWriteFenceEvents;
+    readonly table: string;
+    readonly orgColumn: string;
+    readonly parent?: undefined;
+}
+export interface OrgWriteFenceParentTable {
+    readonly events?: OrgWriteFenceEvents;
+    readonly table: string;
+    readonly orgColumn?: undefined;
+    readonly parent: {
+        readonly fkColumn: string;
+        readonly table: string;
+        readonly key: string;
+        readonly orgColumn: string;
+    };
+}
+export type OrgWriteFenceTable = OrgWriteFenceColumnTable | OrgWriteFenceParentTable;
+export declare class OrgWriteFenceIdentifierError extends Error {
+    constructor(what: string, value: string);
+}
+export declare class OrgWriteFenceDuplicateTableError extends Error {
+    constructor(table: string);
+}
+export declare class OrgWriteFenceTriggersMissingError extends Error {
+    readonly problems: readonly string[];
+    constructor(problems: readonly string[]);
+}
+export declare const ORG_WRITE_FENCE_TRIGGER_NAMES: readonly string[];
+export declare function orgWriteFenceTriggerSql(tables: ReadonlyArray<OrgWriteFenceTable>): string;
+export interface OrgWriteFenceTriggerRow {
+    readonly table_name: string;
+    readonly name: string;
+    readonly type: number;
+    readonly enabled: boolean;
+    readonly args: readonly string[];
+    readonly has_when: boolean;
+}
+export declare const ORG_WRITE_FENCE_TRIGGER_ROWS_SQL = "\n    SELECT c.relname AS table_name,\n           t.tgname AS name,\n           t.tgtype::int AS type,\n           (t.tgenabled = 'O') AS enabled,\n           (t.tgqual IS NOT NULL) AS has_when,\n           CASE WHEN t.tgnargs = 0 THEN ARRAY[]::text[]\n                ELSE regexp_split_to_array(regexp_replace(encode(t.tgargs, 'escape'), '\\\\000$', ''), '\\\\000') END AS args\n    FROM pg_trigger AS t\n    JOIN pg_class AS c ON c.oid = t.tgrelid\n    JOIN pg_namespace AS n ON n.oid = c.relnamespace\n    JOIN pg_proc AS p ON p.oid = t.tgfoid\n    WHERE n.nspname = current_schema()\n      AND NOT t.tgisinternal\n      AND ((t.tgname IN ('xema_org_write_fence', 'xema_org_write_fence_move') AND p.proname = 'xema_org_write_fence_trigger')\n        OR (t.tgname = 'xema_org_write_fence_truncate' AND p.proname = 'xema_org_write_fence_truncate'))";
+export declare function orgWriteFenceStaleRows(rows: readonly OrgWriteFenceTriggerRow[], tables: ReadonlyArray<OrgWriteFenceTable>): OrgWriteFenceTriggerRow[];
+export declare function orgWriteFenceProblems(rows: readonly OrgWriteFenceTriggerRow[], tables: ReadonlyArray<OrgWriteFenceTable>): string[];
+export declare function assertOrgWriteFenceTriggers(db: AdvisoryLockClient, tables: ReadonlyArray<OrgWriteFenceTable>): Promise<void>;
+//# sourceMappingURL=org-write-fence-triggers.d.ts.map

package/dist/lib/org-quiesce/org-write-fence-triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence-triggers.d.ts","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence-triggers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3D,eAAO,MAAM,4BAA4B,yBAAyB,CAAC;AAEnE,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAE7E,eAAO,MAAM,qCAAqC,kCAAkC,CAAC;AA0BrF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,KAAK,CAAC;AAGnD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC7B;AAMD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH;AAGD,MAAM,MAAM,kBAAkB,GAC1B,wBAAwB,GACxB,wBAAwB,CAAC;AAG7B,qBAAa,4BAA6B,SAAQ,KAAK;gBAClC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAM/C;AAGD,qBAAa,gCAAiC,SAAQ,KAAK;gBACtC,KAAK,EAAE,MAAM;CAIjC;AAGD,qBAAa,iCAAkC,SAAQ,KAAK;aACvB,QAAQ,EAAE,SAAS,MAAM,EAAE;gBAA3B,QAAQ,EAAE,SAAS,MAAM,EAAE;CAM/D;AA8ED,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAI1D,CAAC;AAYF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,GACxC,MAAM,CAYR;AAGD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAGD,eAAO,MAAM,gCAAgC,s1BAe8D,CAAC;AAG5G,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,GACxC,uBAAuB,EAAE,CAO3B;AAQD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,uBAAuB,EAAE,EACxC,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,GACxC,MAAM,EAAE,CAyBV;AAeD,wBAAsB,2BAA2B,CAC/C,EAAE,EAAE,kBAAkB,EACtB,MAAM,EAAE,aAAa,CAAC,kBAAkB,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/dist/lib/org-quiesce/org-write-fence-triggers.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORG_WRITE_FENCE_TRIGGER_ROWS_SQL = exports.ORG_WRITE_FENCE_TRIGGER_NAMES = exports.OrgWriteFenceTriggersMissingError = exports.OrgWriteFenceDuplicateTableError = exports.OrgWriteFenceIdentifierError = exports.ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME = exports.ORG_WRITE_FENCE_MOVE_TRIGGER_NAME = exports.ORG_WRITE_FENCE_TRIGGER_NAME = void 0;
+exports.orgWriteFenceTriggerSql = orgWriteFenceTriggerSql;
+exports.orgWriteFenceStaleRows = orgWriteFenceStaleRows;
+exports.orgWriteFenceProblems = orgWriteFenceProblems;
+exports.assertOrgWriteFenceTriggers = assertOrgWriteFenceTriggers;
+exports.ORG_WRITE_FENCE_TRIGGER_NAME = 'xema_org_write_fence';
+exports.ORG_WRITE_FENCE_MOVE_TRIGGER_NAME = 'xema_org_write_fence_move';
+exports.ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME = 'xema_org_write_fence_truncate';
+const TRIGGER_NAME = exports.ORG_WRITE_FENCE_TRIGGER_NAME;
+const TRIGGER_FUNCTION = 'xema_org_write_fence_trigger';
+const TRUNCATE_FUNCTION = 'xema_org_write_fence_truncate';
+const TRIGGER_TYPE_BEFORE_ROW_INSERT = 7;
+const TRIGGER_TYPE_BEFORE_ROW_INSERT_DELETE_UPDATE = 31;
+const TRIGGER_TYPE_BEFORE_ROW_UPDATE = 19;
+const TRIGGER_TYPE_BEFORE_TRUNCATE = 34;
+const IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/u;
+class OrgWriteFenceIdentifierError extends Error {
+    constructor(what, value) {
+        super(`[org-write-fence] ${what} "${value}" must match ${IDENTIFIER_PATTERN.source}.`);
+        this.name = 'OrgWriteFenceIdentifierError';
+    }
+}
+exports.OrgWriteFenceIdentifierError = OrgWriteFenceIdentifierError;
+class OrgWriteFenceDuplicateTableError extends Error {
+    constructor(table) {
+        super(`[org-write-fence] table "${table}" is declared more than once.`);
+        this.name = 'OrgWriteFenceDuplicateTableError';
+    }
+}
+exports.OrgWriteFenceDuplicateTableError = OrgWriteFenceDuplicateTableError;
+class OrgWriteFenceTriggersMissingError extends Error {
+    problems;
+    constructor(problems) {
+        super(`[org-write-fence] ${problems.length} table(s) are not guarded by the ${TRIGGER_NAME} trigger as declared: ${problems.join('; ')}.`);
+        this.problems = problems;
+        this.name = 'OrgWriteFenceTriggersMissingError';
+    }
+}
+exports.OrgWriteFenceTriggersMissingError = OrgWriteFenceTriggersMissingError;
+function identifier(what, value) {
+    if (!IDENTIFIER_PATTERN.test(value)) {
+        throw new OrgWriteFenceIdentifierError(what, value);
+    }
+    return value;
+}
+function triggerArgs(entry) {
+    if (entry.parent === undefined) {
+        return [identifier('orgColumn', entry.orgColumn)];
+    }
+    const { fkColumn, table, key, orgColumn } = entry.parent;
+    return [
+        identifier('parent.fkColumn', fkColumn),
+        identifier('parent.table', table),
+        identifier('parent.key', key),
+        identifier('parent.orgColumn', orgColumn),
+    ];
+}
+function expectedTriggers(entry) {
+    const table = identifier('table', entry.table);
+    const args = triggerArgs(entry);
+    const argList = args.map((arg) => `'${arg}'`).join(', ');
+    const truncate = {
+        name: exports.ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME,
+        type: TRIGGER_TYPE_BEFORE_TRUNCATE,
+        args: [],
+        hasWhen: false,
+        sql: `CREATE TRIGGER ${exports.ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME} BEFORE TRUNCATE ON "${table}" FOR EACH STATEMENT EXECUTE FUNCTION ${TRUNCATE_FUNCTION}();`,
+    };
+    if (entry.events !== 'insert') {
+        return [
+            {
+                name: TRIGGER_NAME,
+                type: TRIGGER_TYPE_BEFORE_ROW_INSERT_DELETE_UPDATE,
+                args,
+                hasWhen: false,
+                sql: `CREATE TRIGGER ${TRIGGER_NAME} BEFORE INSERT OR UPDATE OR DELETE ON "${table}" FOR EACH ROW EXECUTE FUNCTION ${TRIGGER_FUNCTION}(${argList});`,
+            },
+            truncate,
+        ];
+    }
+    const moving = args[0];
+    return [
+        {
+            name: TRIGGER_NAME,
+            type: TRIGGER_TYPE_BEFORE_ROW_INSERT,
+            args,
+            hasWhen: false,
+            sql: `CREATE TRIGGER ${TRIGGER_NAME} BEFORE INSERT ON "${table}" FOR EACH ROW EXECUTE FUNCTION ${TRIGGER_FUNCTION}(${argList});`,
+        },
+        {
+            name: exports.ORG_WRITE_FENCE_MOVE_TRIGGER_NAME,
+            type: TRIGGER_TYPE_BEFORE_ROW_UPDATE,
+            args,
+            hasWhen: true,
+            sql: `CREATE TRIGGER ${exports.ORG_WRITE_FENCE_MOVE_TRIGGER_NAME} BEFORE UPDATE ON "${table}" FOR EACH ROW WHEN (OLD."${moving}" IS DISTINCT FROM NEW."${moving}") EXECUTE FUNCTION ${TRIGGER_FUNCTION}(${argList});`,
+        },
+        truncate,
+    ];
+}
+exports.ORG_WRITE_FENCE_TRIGGER_NAMES = [
+    TRIGGER_NAME,
+    exports.ORG_WRITE_FENCE_MOVE_TRIGGER_NAME,
+    exports.ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME,
+];
+function orgWriteFenceTriggerSql(tables) {
+    const seen = new Set();
+    return tables
+        .flatMap((entry) => {
+        const table = identifier('table', entry.table);
+        if (seen.has(table)) {
+            throw new OrgWriteFenceDuplicateTableError(table);
+        }
+        seen.add(table);
+        return expectedTriggers(entry).map((trigger) => trigger.sql);
+    })
+        .join('\n');
+}
+exports.ORG_WRITE_FENCE_TRIGGER_ROWS_SQL = `
+    SELECT c.relname AS table_name,
+           t.tgname AS name,
+           t.tgtype::int AS type,
+           (t.tgenabled = 'O') AS enabled,
+           (t.tgqual IS NOT NULL) AS has_when,
+           CASE WHEN t.tgnargs = 0 THEN ARRAY[]::text[]
+                ELSE regexp_split_to_array(regexp_replace(encode(t.tgargs, 'escape'), '\\\\000$', ''), '\\\\000') END AS args
+    FROM pg_trigger AS t
+    JOIN pg_class AS c ON c.oid = t.tgrelid
+    JOIN pg_namespace AS n ON n.oid = c.relnamespace
+    JOIN pg_proc AS p ON p.oid = t.tgfoid
+    WHERE n.nspname = current_schema()
+      AND NOT t.tgisinternal
+      AND ((t.tgname IN ('${TRIGGER_NAME}', '${exports.ORG_WRITE_FENCE_MOVE_TRIGGER_NAME}') AND p.proname = '${TRIGGER_FUNCTION}')
+        OR (t.tgname = '${exports.ORG_WRITE_FENCE_TRUNCATE_TRIGGER_NAME}' AND p.proname = '${TRUNCATE_FUNCTION}'))`;
+function orgWriteFenceStaleRows(rows, tables) {
+    const expected = new Set(tables.flatMap((entry) => expectedTriggers(entry).map((trigger) => `${entry.table}\u0000${trigger.name}`)));
+    return rows.filter((row) => !expected.has(`${row.table_name}\u0000${row.name}`));
+}
+function orgWriteFenceProblems(rows, tables) {
+    const problems = [];
+    for (const entry of tables) {
+        for (const trigger of expectedTriggers(entry)) {
+            const found = rows.find((row) => row.table_name === entry.table && row.name === trigger.name);
+            if (found === undefined || !found.enabled) {
+                problems.push(`"${entry.table}" has no enabled ${trigger.name} trigger`);
+            }
+            else if (found.type !== trigger.type) {
+                problems.push(`"${entry.table}" ${trigger.name} has tgtype ${found.type}, expected ${trigger.type} (declared events '${entry.events ?? 'all'}')`);
+            }
+            else if (found.has_when !== trigger.hasWhen) {
+                problems.push(`"${entry.table}" ${trigger.name} ${trigger.hasWhen ? 'has no WHEN clause' : 'has an unexpected WHEN clause'}`);
+            }
+            else if (found.args.join('\u0000') !== trigger.args.join('\u0000')) {
+                problems.push(`"${entry.table}" ${trigger.name} is guarded with (${found.args.join(', ')}) but is declared (${trigger.args.join(', ')})`);
+            }
+        }
+    }
+    return problems;
+}
+async function assertOrgWriteFenceTriggers(db, tables) {
+    const query = Object.assign([exports.ORG_WRITE_FENCE_TRIGGER_ROWS_SQL], {
+        raw: [exports.ORG_WRITE_FENCE_TRIGGER_ROWS_SQL],
+    });
+    const rows = await db.$queryRaw(query);
+    const problems = orgWriteFenceProblems(rows, tables);
+    if (problems.length > 0) {
+        throw new OrgWriteFenceTriggersMissingError(problems);
+    }
+}
+//# sourceMappingURL=org-write-fence-triggers.js.map

package/dist/lib/org-quiesce/org-write-fence-triggers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence-triggers.js","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence-triggers.ts"],"names":[],"mappings":"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"}

package/dist/lib/org-quiesce/org-write-fence.sql.d.ts

@@ -0,0 +1,2 @@
+export declare const ORG_WRITE_FENCE_SQL = "\nCREATE FUNCTION xema_org_quiesce_lock_key(p_org text) RETURNS bigint\nLANGUAGE sql STABLE SET search_path FROM CURRENT AS $fn$\n  SELECT hashtext(current_schema() || ':' || 'org-quiesce:' || p_org)::bigint\n$fn$;\n\nCREATE FUNCTION xema_org_holds_erasure_lock(p_org text) RETURNS boolean\nLANGUAGE sql VOLATILE SET search_path FROM CURRENT AS $fn$\n  SELECT EXISTS (\n    SELECT 1\n    FROM pg_locks AS l, xema_org_quiesce_lock_key(p_org) AS k(key)\n    WHERE l.locktype = 'advisory'\n      AND l.database = (SELECT d.oid FROM pg_database AS d WHERE d.datname = current_database())\n      AND l.pid = pg_backend_pid()\n      AND l.mode = 'ExclusiveLock'\n      AND l.granted\n      AND l.objsubid = 1\n      AND l.classid::bigint = (k.key >> 32) & 4294967295\n      AND l.objid::bigint = k.key & 4294967295\n  )\n$fn$;\n\nCREATE FUNCTION xema_org_is_quiescing(p_org text) RETURNS boolean\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  -- The hot path: one shared advisory lock and one indexed read. The pg_locks\n  -- scan (which takes every lock-manager partition lock) runs ONLY for a\n  -- marked org, never per ordinary row write.\n  PERFORM pg_advisory_xact_lock_shared(xema_org_quiesce_lock_key(p_org));\n  IF EXISTS (SELECT 1 FROM \"org_quiesce_marks\" AS m WHERE m.\"org_id\" = p_org) THEN\n    RETURN NOT xema_org_holds_erasure_lock(p_org);\n  END IF;\n  RETURN false;\nEND\n$fn$;\n\nCREATE FUNCTION xema_org_write_fence(p_org text) RETURNS void\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  IF xema_org_is_quiescing(p_org) THEN\n    RAISE EXCEPTION USING ERRCODE = 'XQ409', MESSAGE = 'ORG_QUIESCING', DETAIL = p_org;\n  END IF;\nEND\n$fn$;\n\nCREATE FUNCTION xema_org_write_fence_org_of_row(p_row jsonb, p_is_new boolean, p_nargs integer, p_a0 text, p_a1 text, p_a2 text, p_a3 text) RETURNS text\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nDECLARE\n  fk_value text;\n  key_type text;\n  parent_org text;\n  found boolean;\nBEGIN\n  IF p_nargs = 1 THEN\n    RETURN p_row ->> p_a0;\n  END IF;\n  IF p_nargs <> 4 THEN\n    RAISE EXCEPTION 'xema_org_write_fence_trigger takes (org_column) or (fk_column, parent_table, parent_key, parent_org_column), got % arguments', p_nargs;\n  END IF;\n  fk_value := p_row ->> p_a0;\n  IF fk_value IS NULL THEN\n    RETURN NULL;\n  END IF;\n  -- The parameter is cast to the parent key's own type, never the column to\n  -- text, so the lookup uses the key's index (a uuid or int key included).\n  SELECT format_type(a.atttypid, a.atttypmod) INTO key_type\n  FROM pg_attribute AS a\n  WHERE a.attrelid = to_regclass(quote_ident(p_a1)) AND a.attname = p_a2 AND NOT a.attisdropped;\n  IF key_type IS NULL THEN\n    RAISE EXCEPTION 'xema_org_write_fence_trigger: parent key %.% does not exist', p_a1, p_a2;\n  END IF;\n  EXECUTE format('SELECT true, %I::text FROM %I WHERE %I = $1::%s', p_a3, p_a1, p_a2, key_type)\n    INTO found, parent_org USING fk_value;\n  IF found IS NOT TRUE THEN\n    -- A row that is written (NEW) must have its parent: without it the org is\n    -- unknown, and an unknown org must never pass the fence.\n    IF p_is_new THEN\n      RAISE EXCEPTION USING ERRCODE = 'XQ404', MESSAGE = 'ORG_FENCE_PARENT_MISSING', DETAIL = fk_value;\n    END IF;\n    -- A row that is removed or replaced (OLD) with no parent passes: an ON\n    -- DELETE CASCADE from the parent runs after the parent row is gone, and\n    -- the parent's own delete was already fenced by its own trigger.\n    RETURN NULL;\n  END IF;\n  RETURN parent_org;\nEND\n$fn$;\n\nCREATE FUNCTION xema_org_write_fence_trigger() RETURNS trigger\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nDECLARE\n  new_org text;\n  old_org text;\nBEGIN\n  IF TG_OP IN ('INSERT', 'UPDATE') THEN\n    new_org := xema_org_write_fence_org_of_row(to_jsonb(NEW), true, TG_NARGS, TG_ARGV[0], TG_ARGV[1], TG_ARGV[2], TG_ARGV[3]);\n    IF new_org IS NOT NULL THEN\n      PERFORM xema_org_write_fence(new_org);\n    END IF;\n  END IF;\n  IF TG_OP IN ('UPDATE', 'DELETE') THEN\n    old_org := xema_org_write_fence_org_of_row(to_jsonb(OLD), false, TG_NARGS, TG_ARGV[0], TG_ARGV[1], TG_ARGV[2], TG_ARGV[3]);\n    IF old_org IS NOT NULL AND old_org IS DISTINCT FROM new_org THEN\n      PERFORM xema_org_write_fence(old_org);\n    END IF;\n  END IF;\n  IF TG_OP = 'DELETE' THEN\n    RETURN OLD;\n  END IF;\n  RETURN NEW;\nEND\n$fn$;\n\nCREATE FUNCTION xema_org_write_fence_truncate() RETURNS trigger\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  RAISE EXCEPTION USING ERRCODE = 'XQ410', MESSAGE = 'ORG_FENCE_TRUNCATE_REFUSED', DETAIL = TG_TABLE_NAME;\nEND\n$fn$;\n\nCREATE FUNCTION xema_org_quiesce_mark(p_org text) RETURNS void\nLANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$\nBEGIN\n  PERFORM pg_advisory_xact_lock(xema_org_quiesce_lock_key(p_org));\n  INSERT INTO \"org_quiesce_marks\" (\"org_id\") VALUES (p_org) ON CONFLICT (\"org_id\") DO NOTHING;\nEND\n$fn$;\n";
+//# sourceMappingURL=org-write-fence.sql.d.ts.map

package/dist/lib/org-quiesce/org-write-fence.sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence.sql.d.ts","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence.sql.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,mBAAmB,64JA+H/B,CAAC"}

package/dist/lib/org-quiesce/org-write-fence.sql.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORG_WRITE_FENCE_SQL = void 0;
+exports.ORG_WRITE_FENCE_SQL = `
+CREATE FUNCTION xema_org_quiesce_lock_key(p_org text) RETURNS bigint
+LANGUAGE sql STABLE SET search_path FROM CURRENT AS $fn$
+  SELECT hashtext(current_schema() || ':' || 'org-quiesce:' || p_org)::bigint
+$fn$;
+
+CREATE FUNCTION xema_org_holds_erasure_lock(p_org text) RETURNS boolean
+LANGUAGE sql VOLATILE SET search_path FROM CURRENT AS $fn$
+  SELECT EXISTS (
+    SELECT 1
+    FROM pg_locks AS l, xema_org_quiesce_lock_key(p_org) AS k(key)
+    WHERE l.locktype = 'advisory'
+      AND l.database = (SELECT d.oid FROM pg_database AS d WHERE d.datname = current_database())
+      AND l.pid = pg_backend_pid()
+      AND l.mode = 'ExclusiveLock'
+      AND l.granted
+      AND l.objsubid = 1
+      AND l.classid::bigint = (k.key >> 32) & 4294967295
+      AND l.objid::bigint = k.key & 4294967295
+  )
+$fn$;
+
+CREATE FUNCTION xema_org_is_quiescing(p_org text) RETURNS boolean
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  -- The hot path: one shared advisory lock and one indexed read. The pg_locks
+  -- scan (which takes every lock-manager partition lock) runs ONLY for a
+  -- marked org, never per ordinary row write.
+  PERFORM pg_advisory_xact_lock_shared(xema_org_quiesce_lock_key(p_org));
+  IF EXISTS (SELECT 1 FROM "org_quiesce_marks" AS m WHERE m."org_id" = p_org) THEN
+    RETURN NOT xema_org_holds_erasure_lock(p_org);
+  END IF;
+  RETURN false;
+END
+$fn$;
+
+CREATE FUNCTION xema_org_write_fence(p_org text) RETURNS void
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  IF xema_org_is_quiescing(p_org) THEN
+    RAISE EXCEPTION USING ERRCODE = 'XQ409', MESSAGE = 'ORG_QUIESCING', DETAIL = p_org;
+  END IF;
+END
+$fn$;
+
+CREATE FUNCTION xema_org_write_fence_org_of_row(p_row jsonb, p_is_new boolean, p_nargs integer, p_a0 text, p_a1 text, p_a2 text, p_a3 text) RETURNS text
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+DECLARE
+  fk_value text;
+  key_type text;
+  parent_org text;
+  found boolean;
+BEGIN
+  IF p_nargs = 1 THEN
+    RETURN p_row ->> p_a0;
+  END IF;
+  IF p_nargs <> 4 THEN
+    RAISE EXCEPTION 'xema_org_write_fence_trigger takes (org_column) or (fk_column, parent_table, parent_key, parent_org_column), got % arguments', p_nargs;
+  END IF;
+  fk_value := p_row ->> p_a0;
+  IF fk_value IS NULL THEN
+    RETURN NULL;
+  END IF;
+  -- The parameter is cast to the parent key's own type, never the column to
+  -- text, so the lookup uses the key's index (a uuid or int key included).
+  SELECT format_type(a.atttypid, a.atttypmod) INTO key_type
+  FROM pg_attribute AS a
+  WHERE a.attrelid = to_regclass(quote_ident(p_a1)) AND a.attname = p_a2 AND NOT a.attisdropped;
+  IF key_type IS NULL THEN
+    RAISE EXCEPTION 'xema_org_write_fence_trigger: parent key %.% does not exist', p_a1, p_a2;
+  END IF;
+  EXECUTE format('SELECT true, %I::text FROM %I WHERE %I = $1::%s', p_a3, p_a1, p_a2, key_type)
+    INTO found, parent_org USING fk_value;
+  IF found IS NOT TRUE THEN
+    -- A row that is written (NEW) must have its parent: without it the org is
+    -- unknown, and an unknown org must never pass the fence.
+    IF p_is_new THEN
+      RAISE EXCEPTION USING ERRCODE = 'XQ404', MESSAGE = 'ORG_FENCE_PARENT_MISSING', DETAIL = fk_value;
+    END IF;
+    -- A row that is removed or replaced (OLD) with no parent passes: an ON
+    -- DELETE CASCADE from the parent runs after the parent row is gone, and
+    -- the parent's own delete was already fenced by its own trigger.
+    RETURN NULL;
+  END IF;
+  RETURN parent_org;
+END
+$fn$;
+
+CREATE FUNCTION xema_org_write_fence_trigger() RETURNS trigger
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+DECLARE
+  new_org text;
+  old_org text;
+BEGIN
+  IF TG_OP IN ('INSERT', 'UPDATE') THEN
+    new_org := xema_org_write_fence_org_of_row(to_jsonb(NEW), true, TG_NARGS, TG_ARGV[0], TG_ARGV[1], TG_ARGV[2], TG_ARGV[3]);
+    IF new_org IS NOT NULL THEN
+      PERFORM xema_org_write_fence(new_org);
+    END IF;
+  END IF;
+  IF TG_OP IN ('UPDATE', 'DELETE') THEN
+    old_org := xema_org_write_fence_org_of_row(to_jsonb(OLD), false, TG_NARGS, TG_ARGV[0], TG_ARGV[1], TG_ARGV[2], TG_ARGV[3]);
+    IF old_org IS NOT NULL AND old_org IS DISTINCT FROM new_org THEN
+      PERFORM xema_org_write_fence(old_org);
+    END IF;
+  END IF;
+  IF TG_OP = 'DELETE' THEN
+    RETURN OLD;
+  END IF;
+  RETURN NEW;
+END
+$fn$;
+
+CREATE FUNCTION xema_org_write_fence_truncate() RETURNS trigger
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  RAISE EXCEPTION USING ERRCODE = 'XQ410', MESSAGE = 'ORG_FENCE_TRUNCATE_REFUSED', DETAIL = TG_TABLE_NAME;
+END
+$fn$;
+
+CREATE FUNCTION xema_org_quiesce_mark(p_org text) RETURNS void
+LANGUAGE plpgsql VOLATILE SET search_path FROM CURRENT AS $fn$
+BEGIN
+  PERFORM pg_advisory_xact_lock(xema_org_quiesce_lock_key(p_org));
+  INSERT INTO "org_quiesce_marks" ("org_id") VALUES (p_org) ON CONFLICT ("org_id") DO NOTHING;
+END
+$fn$;
+`;
+//# sourceMappingURL=org-write-fence.sql.js.map

package/dist/lib/org-quiesce/org-write-fence.sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-write-fence.sql.js","sourceRoot":"","sources":["../../../src/lib/org-quiesce/org-write-fence.sql.ts"],"names":[],"mappings":";;;AAyCa,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+HlC,CAAC"}

package/dist/lib/sdk-owned-migrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdk-owned-migrations.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-owned-migrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,yBAAyB,EAC/B,MAAM,eAAe,CAAC;AAWvB,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAmBnC,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,oBAAoB,EAAE,GACpC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQrB;AA+CD,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,yBAAyB,EACnC,IAAI,EAAE,SAAS,oBAAoB,EAAE,GACpC,OAAO,CAAC,IAAI,CAAC,CAyCf"}
+{"version":3,"file":"sdk-owned-migrations.d.ts","sourceRoot":"","sources":["../../src/lib/sdk-owned-migrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,yBAAyB,EAC/B,MAAM,eAAe,CAAC;AAYvB,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAmBnC,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,oBAAoB,EAAE,GACpC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQrB;AAiDD,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,yBAAyB,EACnC,IAAI,EAAE,SAAS,oBAAoB,EAAE,GACpC,OAAO,CAAC,IAAI,CAAC,CAyCf"}

package/dist/lib/sdk-owned-migrations.js

@@ -5,6 +5,7 @@ exports.applySdkOwnedMigrations = applySdkOwnedMigrations;
 const ledger_rows_1 = require("./ledger-rows");
 const operator_migration_1 = require("./operator-migration");
 const operator_migration_ledger_1 = require("./operator-migration-ledger");
+const org_write_fence_apply_1 = require("./org-quiesce/org-write-fence-apply");
 const owned_table_shape_1 = require("./owned-table-shape");
 const sdk_owned_errors_1 = require("./sdk-owned-errors");
 const sdk_owned_migration_set_1 = require("./sdk-owned-migration-set");
@@ -18,7 +19,10 @@ function sdkOwnedTableOwners(sets) {
     return new Map(all.flatMap((set) => set.tables.map((table) => [table.name, set.owner])));
 }
 async function assertLedgerKnownToImage(database, sets) {
-    const known = new Set(migrationIdsOf([operator_migration_ledger_1.operatorMigrationLedgerMigrations, ...sets]));
+    const known = new Set([
+        ...migrationIdsOf([operator_migration_ledger_1.operatorMigrationLedgerMigrations, ...sets]),
+        org_write_fence_apply_1.ORG_WRITE_FENCE_DECLARATION_ID,
+    ]);
     const recorded = await database.query(`SELECT migration_id FROM "${operator_migration_ledger_1.OPERATOR_MIGRATION_LEDGER_TABLE}" WHERE phase = $1 ORDER BY migration_id`, [ledger_rows_1.OperatorMigrationPhase.Applied]);
     const unknown = recorded.rows
         .map((row) => row.migration_id)

package/dist/lib/sdk-owned-migrations.js.map

@@ -1 +1 @@
-{"version":3,"file":"sdk-owned-migrations.js","sourceRoot":"","sources":["../../src/lib/sdk-owned-migrations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sdk-owned-migrations.js","sourceRoot":"","sources":["../../src/lib/sdk-owned-migrations.ts"],"names":[],"mappings":";;AAyCA,kDAUC;AAiDD,0DA4CC;AAhJD,+CAMuB;AACvB,6DAA8D;AAC9D,2EAGqC;AACrC,+EAAqF;AACrF,2DAA4D;AAC5D,yDAG4B;AAC5B,uEAImC;AACnC,yEAIoC;AAEpC,SAAS,cAAc,CAAC,IAAqC;IAC3D,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAC1B,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAC/B,IAAA,6CAAmB,EAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAClD,CACF,CAAC;AACJ,CAAC;AAMD,SAAgB,mBAAmB,CACjC,IAAqC;IAErC,MAAM,GAAG,GAAG,CAAC,6DAAiC,EAAE,GAAG,IAAI,CAAC,CAAC;IACzD,IAAA,qDAA2B,EAAC,GAAG,CAAC,CAAC;IACjC,OAAO,IAAI,GAAG,CACZ,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAClB,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CACrE,CACF,CAAC;AACJ,CAAC;AAOD,KAAK,UAAU,wBAAwB,CACrC,QAAmC,EACnC,IAAqC;IAErC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC;QACpB,GAAG,cAAc,CAAC,CAAC,6DAAiC,EAAE,GAAG,IAAI,CAAC,CAAC;QAE/D,sDAA8B;KAC/B,CAAC,CAAC;IACH,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,KAAK,CACnC,6BAA6B,2DAA+B,0CAA0C,EACtG,CAAC,oCAAsB,CAAC,OAAO,CAAC,CACjC,CAAC;IACF,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI;SAC1B,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,YAAY,CAAC;SAC9B,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;IACpD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,wDAAqC,CAAC,OAAO,CAAC,CAAC;IAC3D,CAAC;AACH,CAAC;AAuBM,KAAK,UAAU,uBAAuB,CAC3C,QAAmC,EACnC,IAAqC;IAErC,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC1B,MAAM,wBAAwB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC/C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,KAAK,MAAM,SAAS,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;YACvC,MAAM,WAAW,GAAG,IAAA,6CAAmB,EAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;YACtE,MAAM,cAAc,GAAG,IAAA,oBAAM,EAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAE7C,MAAM,OAAO,GACX,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YACpB,MAAM,IAAA,2CAAsB,EAAC,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE;gBAC/D,MAAM,QAAQ,GAAG,MAAM,IAAA,uBAAS,EAC9B,EAAE,EACF,WAAW,EACX,oCAAsB,CAAC,OAAO,CAC/B,CAAC;gBACF,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;oBACtB,IAAI,QAAQ,KAAK,cAAc,EAAE,CAAC;wBAChC,MAAM,IAAI,gDAA6B,CAAC,WAAW,CAAC,CAAC;oBACvD,CAAC;oBACD,OAAO;gBACT,CAAC;gBACD,OAAO,CAAC,OAAO,GAAG,MAAM,IAAA,iDAAsB,EAAC,EAAE,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC;gBACnE,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;oBAC7B,MAAM,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;gBAChC,CAAC;gBACD,MAAM,IAAA,yBAAW,EACf,EAAE,EACF,WAAW,EACX,oCAAsB,CAAC,OAAO,EAC9B,cAAc,CACf,CAAC;YACJ,CAAC,CAAC,CAAC;YACH,IAAI,OAAO,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;gBAC7B,IAAA,mDAAwB,EAAC,GAAG,EAAE,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YAC5D,CAAC;QACH,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;YAC/B,MAAM,IAAA,yCAAqB,EAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/lib/service-migration-scan.d.ts

@@ -1,3 +1,4 @@
+import type { SdkOwnedTablePriorCreator } from './sdk-owned-migration-set';
 export declare function sdkOwnedTableNamedByMigration(sql: string, tables: readonly string[]): string | undefined;
-export declare function assertServiceMigrationsLeaveSdkOwnedTablesAlone(workspaceDir: string, ownerOfTable: ReadonlyMap<string, string>): Promise<void>;
+export declare function assertServiceMigrationsLeaveSdkOwnedTablesAlone(workspaceDir: string, ownerOfTable: ReadonlyMap<string, string>, priorCreators: readonly SdkOwnedTablePriorCreator[]): Promise<void>;
 //# sourceMappingURL=service-migration-scan.d.ts.map

package/dist/lib/service-migration-scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-migration-scan.d.ts","sourceRoot":"","sources":["../../src/lib/service-migration-scan.ts"],"names":[],"mappings":"AAgKA,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,GAAG,SAAS,CAuBpB;AAOD,wBAAsB,+CAA+C,CACnE,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CAgBf"}
+{"version":3,"file":"service-migration-scan.d.ts","sourceRoot":"","sources":["../../src/lib/service-migration-scan.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AA4J3E,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,MAAM,GAAG,SAAS,CAuBpB;AAeD,wBAAsB,+CAA+C,CACnE,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACzC,aAAa,EAAE,SAAS,yBAAyB,EAAE,GAClD,OAAO,CAAC,IAAI,CAAC,CA4Bf"}