@antelopejs/postgres 0.2.1 → 0.2.3

package/dist/test/unit/ddl.spec.js

@@ -5,15 +5,7 @@ const types_1 = require("../../implementations/database/types");
 const fields_1 = require("../../implementations/database/fields");
 const identifier_1 = require("../../implementations/database/identifier");
 const ddl_1 = require("../../implementations/database/ddl");
-const vehicles = {
-    fields: { car: "string", price: "number", tags: "string[]" },
-    indexes: {
-        price: {},
-        tags: { multi: true },
-        byCar: { fields: ["car", "price"] },
-    },
-};
-const VEHICLES_PLAN = (0, ddl_1.BuildTablePlan)("vehicles", vehicles, (0, fields_1.ParseTable)(vehicles, "s.vehicles"));
+const ddl_fixture_1 = require("./ddl-fixture");
 const TABLE_PREFIX = "t_";
 const ESCAPED_LITERAL_PREFIX = "E'";
 const COMMENT_PATTERN = /^COMMENT ON INDEX "shop"\."[^"]+" IS (E?'.*')$/;
@@ -24,11 +16,8 @@ function FindIndex(plan, name) {
     }
     return found;
 }
-function PlanFor(tableId, definition) {
-    return (0, ddl_1.BuildTablePlan)(tableId, definition, (0, fields_1.ParseTable)(definition, `s.${tableId}`));
-}
 function BuildOne(definition) {
-    return PlanFor("t", definition).indexes[0];
+    return (0, ddl_fixture_1.PlanFor)("t", definition).indexes[0];
 }
 function DecodeLiteral(literal) {
     const isEscaped = literal.startsWith(ESCAPED_LITERAL_PREFIX);
@@ -38,7 +27,7 @@ function DecodeLiteral(literal) {
 }
 describe("BuildTablePlan", () => {
     it("orders the reserved columns around the declared ones", () => {
-        (0, chai_1.expect)(VEHICLES_PLAN.columns.map((column) => column.name)).to.deep.equal([
+        (0, chai_1.expect)(ddl_fixture_1.VEHICLES_PLAN.columns.map((column) => column.name)).to.deep.equal([
             "_id",
             "_instance",
             "car",
@@ -48,39 +37,39 @@ describe("BuildTablePlan", () => {
         ]);
     });
     it("maps declared fields to their physical types", () => {
-        (0, chai_1.expect)(VEHICLES_PLAN.columns[3]).to.deep.equal({
+        (0, chai_1.expect)(ddl_fixture_1.VEHICLES_PLAN.columns[3]).to.deep.equal({
             name: "price",
             type: "double precision",
             declared: { field: "price", type: types_1.FLOAT },
         });
     });
     it("leaves the reserved columns undeclared, since no field is stored in them", () => {
-        const reserved = [0, 1, VEHICLES_PLAN.columns.length - 1];
+        const reserved = [0, 1, ddl_fixture_1.VEHICLES_PLAN.columns.length - 1];
         for (const at of reserved) {
-            (0, chai_1.expect)(VEHICLES_PLAN.columns[at].declared).to.equal(undefined);
+            (0, chai_1.expect)(ddl_fixture_1.VEHICLES_PLAN.columns[at].declared).to.equal(undefined);
         }
     });
     it("gives the reserved columns their constraints", () => {
-        (0, chai_1.expect)((0, ddl_1.ColumnDdl)(VEHICLES_PLAN.columns[1])).to.equal(`"_instance" text NOT NULL DEFAULT ''`);
-        (0, chai_1.expect)((0, ddl_1.ColumnDdl)(VEHICLES_PLAN.columns[5])).to.equal(`"_extra" jsonb NOT NULL DEFAULT '{}'::jsonb`);
-        (0, chai_1.expect)((0, ddl_1.ColumnDdl)(VEHICLES_PLAN.columns[3])).to.equal(`"price" double precision`);
+        (0, chai_1.expect)((0, ddl_1.ColumnDdl)(ddl_fixture_1.VEHICLES_PLAN.columns[1])).to.equal(`"_instance" text NOT NULL DEFAULT ''`);
+        (0, chai_1.expect)((0, ddl_1.ColumnDdl)(ddl_fixture_1.VEHICLES_PLAN.columns[5])).to.equal(`"_extra" jsonb NOT NULL DEFAULT '{}'::jsonb`);
+        (0, chai_1.expect)((0, ddl_1.ColumnDdl)(ddl_fixture_1.VEHICLES_PLAN.columns[3])).to.equal(`"price" double precision`);
     });
     it("leads a btree index with _instance", () => {
-        const index = FindIndex(VEHICLES_PLAN, "vehicles_price");
+        const index = FindIndex(ddl_fixture_1.VEHICLES_PLAN, "vehicles_price");
         (0, chai_1.expect)(index.method).to.equal("btree");
         (0, chai_1.expect)(index.keys).to.deep.equal([`"_instance"`, `"price"`]);
     });
     it("uses a bare gin index for a multi index over a jsonb field", () => {
-        const index = FindIndex(VEHICLES_PLAN, "vehicles_tags");
+        const index = FindIndex(ddl_fixture_1.VEHICLES_PLAN, "vehicles_tags");
         (0, chai_1.expect)(index.method).to.equal("gin");
         (0, chai_1.expect)(index.keys).to.deep.equal([`"tags"`]);
     });
     it("expands a compound index in declaration order", () => {
-        const index = FindIndex(VEHICLES_PLAN, "vehicles_byCar");
+        const index = FindIndex(ddl_fixture_1.VEHICLES_PLAN, "vehicles_byCar");
         (0, chai_1.expect)(index.keys).to.deep.equal([`"_instance"`, `"car"`, `"price"`]);
     });
     it("indexes an undeclared field through _extra", () => {
-        const out = PlanFor("t", { fields: {}, indexes: { ref: {} } });
+        const out = (0, ddl_fixture_1.PlanFor)("t", { fields: {}, indexes: { ref: {} } });
         (0, chai_1.expect)(out.indexes[0].keys).to.deep.equal([
             `"_instance"`,
             `("_extra" -> 'ref')`,
@@ -117,8 +106,10 @@ describe("BuildTablePlan", () => {
         (0, chai_1.expect)(index.method).to.equal("btree");
         (0, chai_1.expect)(index.keys).to.deep.equal([`"_instance"`, `("_extra" -> 'ref')`]);
     });
+});
+describe("BuildTablePlan", () => {
     it("adds an unprefixed __g twin to a crossInstance btree index", () => {
-        const plan = PlanFor("t", {
+        const plan = (0, ddl_fixture_1.PlanFor)("t", {
             fields: { car: "string", price: "number" },
             indexes: { byCar: { fields: ["car", "price"], crossInstance: true } },
         });
@@ -133,7 +124,7 @@ describe("BuildTablePlan", () => {
         (0, chai_1.expect)(unscoped.signature).to.not.equal(scoped.signature);
     });
     it("keeps a crossInstance gin index as one bare index", () => {
-        const plan = PlanFor("t", {
+        const plan = (0, ddl_fixture_1.PlanFor)("t", {
             fields: { tags: "string[]" },
             indexes: { tags: { multi: true, crossInstance: true } },
         });
@@ -142,7 +133,7 @@ describe("BuildTablePlan", () => {
     });
     it("fits the __g name into the identifier limit", () => {
         const longId = "x".repeat(70);
-        const plan = PlanFor("t", {
+        const plan = (0, ddl_fixture_1.PlanFor)("t", {
             fields: {},
             indexes: { [longId]: { crossInstance: true } },
         });
@@ -152,44 +143,73 @@ describe("BuildTablePlan", () => {
         (0, chai_1.expect)(Buffer.byteLength(names[1])).to.be.at.most(63);
     });
     it("signs an index with its method and keys", () => {
-        const index = FindIndex(VEHICLES_PLAN, "vehicles_price");
+        const index = FindIndex(ddl_fixture_1.VEHICLES_PLAN, "vehicles_price");
         (0, chai_1.expect)(index.signature).to.equal(`antelopejs:1:btree:"_instance","price"`);
     });
     it("emits a create table statement with the composite primary key", () => {
-        const sql = (0, ddl_1.CreateTableSql)("shop", VEHICLES_PLAN);
+        const sql = (0, ddl_1.CreateTableSql)("shop", ddl_fixture_1.VEHICLES_PLAN);
         (0, chai_1.expect)(sql).to.contain(`CREATE TABLE IF NOT EXISTS "shop"."vehicles" (`);
         (0, chai_1.expect)(sql).to.contain(`PRIMARY KEY ("_instance", "_id")`);
     });
     it("emits a concurrent create index statement and its signature comment", () => {
-        const index = FindIndex(VEHICLES_PLAN, "vehicles_price");
-        (0, chai_1.expect)((0, ddl_1.CreateIndexSql)("shop", VEHICLES_PLAN, index)).to.deep.equal([
+        const index = FindIndex(ddl_fixture_1.VEHICLES_PLAN, "vehicles_price");
+        (0, chai_1.expect)((0, ddl_1.CreateIndexSql)("shop", ddl_fixture_1.VEHICLES_PLAN, index)).to.deep.equal([
             `CREATE INDEX CONCURRENTLY "vehicles_price" ON "shop"."vehicles" USING btree ("_instance", "price")`,
             `COMMENT ON INDEX "shop"."vehicles_price" IS 'antelopejs:1:btree:"_instance","price"'`,
         ]);
     });
     it("round-trips a signature over a hostile field name", () => {
         const hostile = "it's\\bad";
-        const hostilePlan = PlanFor("t", {
+        const hostilePlan = (0, ddl_fixture_1.PlanFor)("t", {
             fields: {},
             indexes: { [hostile]: {} },
         });
         const index = hostilePlan.indexes[0];
         const comment = (0, ddl_1.CreateIndexSql)("shop", hostilePlan, index)[1];
         const matched = COMMENT_PATTERN.exec(comment);
-        (0, chai_1.expect)(matched, comment).to.not.equal(null);
+        if (matched === null) {
+            chai_1.expect.fail(comment);
+        }
         (0, chai_1.expect)(DecodeLiteral(matched[1])).to.equal(index.signature);
     });
+    it("builds a unique index keyed by instance, with a marked signature", () => {
+        const plan = (0, ddl_fixture_1.PlanFor)("t", {
+            fields: { email: "string" },
+            indexes: { email: { unique: true } },
+        });
+        const [index] = plan.indexes;
+        (0, chai_1.expect)(index.isUnique).to.equal(true);
+        (0, chai_1.expect)(index.signature).to.equal(`antelopejs:1:btree:unique:"_instance","email"`);
+        (0, chai_1.expect)((0, ddl_1.CreateIndexSql)("shop", plan, index)[0]).to.equal(`CREATE UNIQUE INDEX CONCURRENTLY "t_email" ON "shop"."t" USING btree ("_instance", "email")`);
+    });
+    it("keeps the __g twin of a unique index non-unique", () => {
+        const plan = (0, ddl_fixture_1.PlanFor)("t", {
+            fields: { email: "string" },
+            indexes: { email: { unique: true, crossInstance: true } },
+        });
+        const [scoped, unscoped] = plan.indexes;
+        (0, chai_1.expect)(scoped.isUnique).to.equal(true);
+        (0, chai_1.expect)(unscoped.name).to.equal("t_email__g");
+        (0, chai_1.expect)(unscoped.isUnique).to.equal(false);
+        (0, chai_1.expect)((0, ddl_1.CreateIndexSql)("shop", plan, unscoped)[0]).to.match(/^CREATE INDEX CONCURRENTLY/);
+    });
+    it("refuses a unique index over an array field's elements", () => {
+        (0, chai_1.expect)(() => BuildOne({
+            fields: { tags: "string[]" },
+            indexes: { tags: { multi: true, unique: true } },
+        })).to.throw(/unique and multi over an array field/);
+    });
 });
 describe("ServesCrossInstance", () => {
-    const shape = (0, fields_1.ParseTable)(vehicles, "s.vehicles");
+    const model = (0, fields_1.ParseTable)(ddl_fixture_1.vehicles, "s.vehicles");
     it("is true for a declared crossInstance index", () => {
-        (0, chai_1.expect)((0, ddl_1.ServesCrossInstance)("price", { crossInstance: true }, shape)).to.equal(true);
+        (0, chai_1.expect)((0, ddl_1.ServesCrossInstance)("price", { crossInstance: true }, model)).to.equal(true);
     });
     it("is false for a btree index that is not crossInstance", () => {
-        (0, chai_1.expect)((0, ddl_1.ServesCrossInstance)("price", {}, shape)).to.equal(false);
+        (0, chai_1.expect)((0, ddl_1.ServesCrossInstance)("price", {}, model)).to.equal(false);
     });
     it("is true for a gin index, which carries no instance prefix", () => {
-        (0, chai_1.expect)((0, ddl_1.ServesCrossInstance)("tags", { multi: true }, shape)).to.equal(true);
+        (0, chai_1.expect)((0, ddl_1.ServesCrossInstance)("tags", { multi: true }, model)).to.equal(true);
     });
 });
 describe("IsAdapterIndex", () => {
@@ -208,15 +228,15 @@ describe("IsAdapterIndex", () => {
 describe("AssertDistinctNames", () => {
     it("accepts a schema whose generated names are all distinct", () => {
         const plans = [
-            VEHICLES_PLAN,
-            PlanFor("owners", { fields: { name: "string" }, indexes: { name: {} } }),
+            ddl_fixture_1.VEHICLES_PLAN,
+            (0, ddl_fixture_1.PlanFor)("owners", { fields: { name: "string" }, indexes: { name: {} } }),
         ];
         (0, chai_1.expect)(() => (0, ddl_1.AssertDistinctNames)(plans)).to.not.throw();
     });
     it("rejects two indexes on one table that collide on one name", () => {
         const long = "i".repeat(100);
         const truncated = (0, identifier_1.PgIdentifier)(`${TABLE_PREFIX}${long}`).slice(TABLE_PREFIX.length);
-        const plan = PlanFor("t", {
+        const plan = (0, ddl_fixture_1.PlanFor)("t", {
             fields: {},
             indexes: { [long]: {}, [truncated]: {} },
         });
@@ -227,8 +247,8 @@ describe("AssertDistinctNames", () => {
     });
     it("rejects two tables whose indexes map to one name", () => {
         const plans = [
-            PlanFor("a", { fields: {}, indexes: { b_c: {} } }),
-            PlanFor("a_b", { fields: {}, indexes: { c: {} } }),
+            (0, ddl_fixture_1.PlanFor)("a", { fields: {}, indexes: { b_c: {} } }),
+            (0, ddl_fixture_1.PlanFor)("a_b", { fields: {}, indexes: { c: {} } }),
         ];
         const check = () => (0, ddl_1.AssertDistinctNames)(plans);
         (0, chai_1.expect)(check).to.throw("a_b_c");
@@ -237,8 +257,8 @@ describe("AssertDistinctNames", () => {
     });
     it("rejects an index that collides with a sibling table", () => {
         const plans = [
-            VEHICLES_PLAN,
-            PlanFor("vehicles_price", { fields: {}, indexes: {} }),
+            ddl_fixture_1.VEHICLES_PLAN,
+            (0, ddl_fixture_1.PlanFor)("vehicles_price", { fields: {}, indexes: {} }),
         ];
         const check = () => (0, ddl_1.AssertDistinctNames)(plans);
         (0, chai_1.expect)(check).to.throw("vehicles_price");
@@ -246,326 +266,4 @@ describe("AssertDistinctNames", () => {
         (0, chai_1.expect)(check).to.throw(/table 'vehicles_price'/);
     });
 });
-const SAFE = "safe";
-const DESTRUCTIVE = "destructive";
-const SCHEMA = "shop";
-const VEHICLES_TARGET = `"shop"."vehicles"`;
-const DECLARED_INDEX_COUNT = 3;
-const dated = {
-    fields: { manufactured: "date" },
-    indexes: {},
-};
-const everyType = {
-    fields: {
-        label: "string",
-        amount: "number",
-        active: "boolean",
-        at: "date",
-        payload: "object",
-        tags: "string[]",
-    },
-    indexes: {},
-};
-const CATALOG_TYPES = {
-    text: "text",
-    "double precision": "double precision",
-    boolean: "boolean",
-    timestamptz: "timestamp with time zone",
-    jsonb: "jsonb",
-};
-const EMPTY = { columns: [], indexes: [] };
-const FULL_COLUMNS = [
-    { name: "_id", type: "text" },
-    { name: "_instance", type: "text" },
-    { name: "car", type: "text" },
-    { name: "price", type: "double precision" },
-    { name: "tags", type: "jsonb" },
-    { name: "_extra", type: "jsonb" },
-];
-const RETYPED_COLUMNS = FULL_COLUMNS.map((column) => column.name === "price" ? { name: column.name, type: "text" } : column);
-const RETIRED_COLUMNS = [
-    ...FULL_COLUMNS,
-    { name: "retired", type: "text" },
-];
-const UNCASTABLE_COLUMNS = FULL_COLUMNS.map((column) => column.name === "price" ? { name: column.name, type: "boolean" } : column);
-const DRIFTED_TAGS_INDEX = {
-    name: "vehicles_tags",
-    signature: `antelopejs:1:gin:"outdated"`,
-    valid: true,
-};
-const PRICE_SIGNATURE = `antelopejs:1:btree:"_instance","price"`;
-const DRIFTED_PRICE_INDEX = {
-    name: "vehicles_price",
-    signature: `antelopejs:1:btree:"price"`,
-    valid: true,
-};
-const DROP_PRICE = `DROP INDEX CONCURRENTLY IF EXISTS "shop"."vehicles_price"`;
-const DROP_PRICE_REPLACEMENT = `DROP INDEX CONCURRENTLY IF EXISTS "shop"."vehicles_price__next"`;
-const CREATE_PRICE = `CREATE INDEX CONCURRENTLY "vehicles_price"`;
-const CREATE_PRICE_REPLACEMENT = `CREATE INDEX CONCURRENTLY "vehicles_price__next"`;
-const RENAME_PRICE_REPLACEMENT = `ALTER INDEX "shop"."vehicles_price__next" RENAME TO "vehicles_price"`;
-function OtherIndexes(plan, name) {
-    return SignedIndexes(plan).filter((index) => index.name !== name);
-}
-function StartsAt(statements, prefix) {
-    return statements.findIndex((sql) => sql.startsWith(prefix));
-}
-function Existing(columns, indexes = []) {
-    return { columns, indexes };
-}
-function SignedIndexes(plan) {
-    return plan.indexes.map((index) => ({
-        name: index.name,
-        signature: index.signature,
-        valid: true,
-    }));
-}
-function CatalogType(type) {
-    if (!Object.hasOwn(CATALOG_TYPES, type)) {
-        throw new Error(`No catalog spelling recorded for physical type '${type}'`);
-    }
-    return CATALOG_TYPES[type];
-}
-function CatalogColumns(plan) {
-    return plan.columns.map((column) => ({
-        name: column.name,
-        type: CatalogType(column.type),
-    }));
-}
-const IsIndexDrop = (sql) => sql.startsWith("DROP INDEX");
-const IsColumnChange = (sql) => sql.startsWith("ALTER TABLE");
-function FirstAt(statements, matches) {
-    const position = statements.findIndex(matches);
-    if (position < 0) {
-        throw new Error(`No statement matched: ${statements.join(" | ")}`);
-    }
-    return position;
-}
-function LastAt(statements, matches) {
-    return statements.reduce((found, sql, position) => (matches(sql) ? position : found), FirstAt(statements, matches));
-}
-describe("PlanTable", () => {
-    it("creates everything when the table is absent", () => {
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, EMPTY, SAFE);
-        (0, chai_1.expect)(out.statements).to.have.lengthOf(1);
-        (0, chai_1.expect)(out.statements[0]).to.contain("CREATE TABLE IF NOT EXISTS");
-        (0, chai_1.expect)(out.indexStatements.filter((sql) => sql.startsWith("CREATE INDEX CONCURRENTLY"))).to.have.lengthOf(DECLARED_INDEX_COUNT);
-        (0, chai_1.expect)(out.warnings).to.deep.equal([]);
-    });
-    it("adds only the missing columns", () => {
-        const actual = Existing([
-            { name: "_id", type: "text" },
-            { name: "_instance", type: "text" },
-            { name: "car", type: "text" },
-            { name: "_extra", type: "jsonb" },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        const added = out.statements.filter((sql) => sql.includes("ADD COLUMN"));
-        (0, chai_1.expect)(added).to.deep.equal([
-            `ALTER TABLE ${VEHICLES_TARGET} ADD COLUMN IF NOT EXISTS "price" double precision`,
-            `ALTER TABLE ${VEHICLES_TARGET} ADD COLUMN IF NOT EXISTS "tags" jsonb`,
-        ]);
-    });
-    it("moves each added column's field out of the overflow document, in the same transaction", () => {
-        const actual = Existing([
-            { name: "_id", type: "text" },
-            { name: "_instance", type: "text" },
-            { name: "car", type: "text" },
-            { name: "_extra", type: "jsonb" },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        const filled = out.statements.filter((sql) => sql.startsWith("UPDATE"));
-        (0, chai_1.expect)(filled).to.have.lengthOf(2);
-        (0, chai_1.expect)(filled[0]).to.contain(`UPDATE ${VEHICLES_TARGET} SET "price" =`);
-        (0, chai_1.expect)(filled[0]).to.contain(`"_extra" = "_extra" - 'price'`);
-        (0, chai_1.expect)(filled[0]).to.contain(`WHERE "price" IS NULL`);
-        const added = out.statements.indexOf(out.statements.filter((sql) => sql.includes(`"price"`))[0]);
-        (0, chai_1.expect)(out.statements[added + 1]).to.equal(filled[0]);
-    });
-    it("reads the stored value as the column's type, so a mistyped one stays put", () => {
-        const actual = Existing([
-            { name: "_id", type: "text" },
-            { name: "_instance", type: "text" },
-            { name: "car", type: "text" },
-            { name: "tags", type: "jsonb" },
-            { name: "_extra", type: "jsonb" },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        const filled = out.statements.filter((sql) => sql.startsWith("UPDATE"));
-        (0, chai_1.expect)(filled).to.have.lengthOf(1);
-        (0, chai_1.expect)(filled[0]).to.contain("jsonb_typeof");
-        (0, chai_1.expect)(filled[0]).to.contain("IS NOT NULL");
-        (0, chai_1.expect)(filled[0]).to.contain("'null'::jsonb");
-    });
-    it("plans no backfill where nothing was added", () => {
-        const actual = Existing([
-            { name: "_id", type: "text" },
-            { name: "_instance", type: "text" },
-            { name: "car", type: "text" },
-            { name: "price", type: "double precision" },
-            { name: "tags", type: "jsonb" },
-            { name: "_extra", type: "jsonb" },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.statements.filter((sql) => sql.startsWith("UPDATE"))).to.deep.equal([]);
-    });
-    it("accepts the catalog spelling of a timestamp column", () => {
-        const plan = (0, ddl_1.BuildTablePlan)("v", dated, (0, fields_1.ParseTable)(dated, "s.v"));
-        const actual = Existing([
-            { name: "_id", type: "text" },
-            { name: "_instance", type: "text" },
-            { name: "manufactured", type: "timestamp with time zone" },
-            { name: "_extra", type: "jsonb" },
-        ]);
-        (0, chai_1.expect)((0, ddl_1.PlanTable)(SCHEMA, plan, actual, SAFE).statements).to.deep.equal([]);
-    });
-    it("accepts the catalog spelling of every physical type", () => {
-        const plan = (0, ddl_1.BuildTablePlan)("v", everyType, (0, fields_1.ParseTable)(everyType, "s.v"));
-        const actual = Existing(CatalogColumns(plan));
-        (0, chai_1.expect)((0, ddl_1.PlanTable)(SCHEMA, plan, actual, SAFE).statements).to.deep.equal([]);
-    });
-    it("refuses a type change in safe mode, naming the field", () => {
-        const actual = Existing(RETYPED_COLUMNS);
-        const converge = () => (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(converge).to.throw(/price/);
-        (0, chai_1.expect)(converge).to.throw(/destructive/);
-    });
-    it("alters a changed type in destructive mode", () => {
-        const actual = Existing(RETYPED_COLUMNS);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, DESTRUCTIVE);
-        (0, chai_1.expect)(out.statements).to.contain(`ALTER TABLE ${VEHICLES_TARGET} ALTER COLUMN "price" TYPE double precision USING ("price"::text::double precision)`);
-    });
-    it("routes the destructive cast through text when no direct cast exists", () => {
-        const actual = Existing(UNCASTABLE_COLUMNS);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, DESTRUCTIVE);
-        (0, chai_1.expect)(out.statements).to.contain(`ALTER TABLE ${VEHICLES_TARGET} ALTER COLUMN "price" TYPE double precision USING ("price"::text::double precision)`);
-    });
-    it("refuses to add a not-null column with no default to a live table", () => {
-        const actual = Existing(FULL_COLUMNS.filter((column) => column.name !== "_id"));
-        const converge = () => (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, DESTRUCTIVE);
-        (0, chai_1.expect)(converge).to.throw(/_id/);
-        (0, chai_1.expect)(converge).to.throw(/not created by this adapter/);
-    });
-    it("warns about an undeclared column in safe mode and keeps it", () => {
-        const actual = Existing(RETIRED_COLUMNS, SignedIndexes(VEHICLES_PLAN));
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.statements).to.deep.equal([]);
-        (0, chai_1.expect)(out.warnings[0]).to.match(/retired/);
-    });
-    it("drops an undeclared column in destructive mode", () => {
-        const actual = Existing(RETIRED_COLUMNS, SignedIndexes(VEHICLES_PLAN));
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, DESTRUCTIVE);
-        (0, chai_1.expect)(out.statements).to.contain(`ALTER TABLE ${VEHICLES_TARGET} DROP COLUMN "retired"`);
-    });
-    it("leaves a matching index alone", () => {
-        const actual = Existing(FULL_COLUMNS, SignedIndexes(VEHICLES_PLAN));
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.indexStatements).to.deep.equal([]);
-    });
-    it("builds indexes outside the transaction", () => {
-        const actual = Existing(FULL_COLUMNS);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.statements).to.deep.equal([]);
-        (0, chai_1.expect)(out.indexStatements).to.have.lengthOf(DECLARED_INDEX_COUNT * 2);
-    });
-    it("builds a drifted index's replacement before it drops the index", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            ...OtherIndexes(VEHICLES_PLAN, "vehicles_price"),
-            DRIFTED_PRICE_INDEX,
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.statements).to.deep.equal([]);
-        (0, chai_1.expect)(out.indexStatements).to.deep.equal([
-            `${CREATE_PRICE_REPLACEMENT} ON ${VEHICLES_TARGET} USING btree ("_instance", "price")`,
-            `COMMENT ON INDEX "shop"."vehicles_price__next" IS '${PRICE_SIGNATURE}'`,
-            DROP_PRICE,
-            RENAME_PRICE_REPLACEMENT,
-        ]);
-    });
-    it("replaces an index we own but never signed", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            ...OtherIndexes(VEHICLES_PLAN, "vehicles_price"),
-            { name: "vehicles_price", valid: true },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(StartsAt(out.indexStatements, CREATE_PRICE_REPLACEMENT)).to.equal(0);
-        (0, chai_1.expect)(out.indexStatements).to.contain(RENAME_PRICE_REPLACEMENT);
-    });
-    it("drops and rebuilds an index a failed concurrent build left invalid", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            ...OtherIndexes(VEHICLES_PLAN, "vehicles_price"),
-            { name: "vehicles_price", signature: PRICE_SIGNATURE, valid: false },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.indexStatements[0]).to.equal(DROP_PRICE);
-        (0, chai_1.expect)(StartsAt(out.indexStatements, CREATE_PRICE)).to.equal(1);
-    });
-    it("clears a replacement a failed rebuild left behind", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            ...SignedIndexes(VEHICLES_PLAN),
-            { name: "vehicles_price__next", valid: false },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.indexStatements).to.deep.equal([DROP_PRICE_REPLACEMENT]);
-    });
-    it("swaps in a ready replacement when a crash left the index missing", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            ...OtherIndexes(VEHICLES_PLAN, "vehicles_price"),
-            { name: "vehicles_price__next", signature: PRICE_SIGNATURE, valid: true },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.indexStatements).to.deep.equal([RENAME_PRICE_REPLACEMENT]);
-    });
-    it("drops an adapter index whose declaration is gone, after every build", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            {
-                name: "vehicles_retired",
-                signature: `antelopejs:1:btree:"_instance","retired"`,
-                valid: true,
-            },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.indexStatements.at(-1)).to.equal(`DROP INDEX CONCURRENTLY IF EXISTS "shop"."vehicles_retired"`);
-    });
-    it("drops the __g twin once an index is no longer crossInstance", () => {
-        const shared = PlanFor("vehicles", {
-            fields: vehicles.fields,
-            indexes: { ...vehicles.indexes, price: { crossInstance: true } },
-        });
-        const actual = Existing(FULL_COLUMNS, SignedIndexes(shared));
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.indexStatements).to.deep.equal([
-            `DROP INDEX CONCURRENTLY IF EXISTS "shop"."vehicles_price__g"`,
-        ]);
-    });
-    it("leaves a hand-made index alone", () => {
-        const actual = Existing(FULL_COLUMNS, [
-            ...SignedIndexes(VEHICLES_PLAN),
-            { name: "operator_hunch", valid: true },
-            { name: "operator_broken", valid: false },
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE);
-        (0, chai_1.expect)(out.statements).to.deep.equal([]);
-        (0, chai_1.expect)(out.indexStatements).to.deep.equal([]);
-    });
-    it("drops obsolete indexes inside the transaction before a column retype", () => {
-        const actual = Existing(RETYPED_COLUMNS, [
-            ...OtherIndexes(VEHICLES_PLAN, "vehicles_tags"),
-            DRIFTED_TAGS_INDEX,
-        ]);
-        const out = (0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, DESTRUCTIVE);
-        (0, chai_1.expect)(LastAt(out.statements, IsIndexDrop)).to.be.lessThan(FirstAt(out.statements, IsColumnChange));
-        (0, chai_1.expect)(out.statements[0]).to.equal(`DROP INDEX IF EXISTS "shop"."vehicles_tags"`);
-        (0, chai_1.expect)(out.indexStatements).to.have.lengthOf(2);
-        (0, chai_1.expect)(out.indexStatements[0]).to.match(/^CREATE INDEX CONCURRENTLY "vehicles_tags"/);
-    });
-    it("emits nothing against the state its own creation produces", () => {
-        const actual = Existing(CatalogColumns(VEHICLES_PLAN), SignedIndexes(VEHICLES_PLAN));
-        (0, chai_1.expect)((0, ddl_1.PlanTable)(SCHEMA, VEHICLES_PLAN, actual, SAFE)).to.deep.equal({
-            statements: [],
-            indexStatements: [],
-            warnings: [],
-        });
-    });
-});
 //# sourceMappingURL=ddl.spec.js.map