@apso/cli 0.43.4 → 0.45.0

package/dist/lib/ddl/change.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downDdl = exports.changeDdl = void 0;
+/**
+ * Render an answered migration plan as the SQL that moves a database from
+ * the deployed .apsorc to the new one.
+ *
+ * Renames come first: the answered renames are applied to the deployed
+ * schema and its model rebuilt. Both models are built the same way, so their
+ * objects pair up by position and every name that differs becomes a RENAME
+ * (tables, columns, sequences, constraints, indexes, enum types). The renamed
+ * model is then diffed against the new one by identity, and the plan's
+ * answers supply the data steps. Statements run in a fixed order so data is
+ * moved before anything it lives in is dropped.
+ */
+const apsorc_parser_1 = require("../apsorc-parser");
+const plan_1 = require("../plan");
+const _1 = require(".");
+const answered = (plan, kind) => plan.questions.filter((x) => x.kind === kind && x.answer);
+/** "field:Contact.phone" -> ["Contact", "phone"]; "enum:Contact.status:archived" -> [..., "archived"]. */
+const subject = (id) => {
+    const [entity, rest = ""] = id.slice(id.indexOf(":") + 1).split(".");
+    const [field, value] = rest.split(":");
+    return { entity, field, value };
+};
+/** The deployed .apsorc with every answered rename applied. */
+function applyRenames(before, after, plan) {
+    var _a, _b, _c;
+    const copy = JSON.parse(JSON.stringify(before));
+    for (const x of answered(plan, "removedField")) {
+        if (!x.answer.startsWith("rename:"))
+            continue;
+        const { entity, field } = subject(x.id);
+        const f = (_b = (_a = copy.entities
+            .find((e) => e.name === entity)) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b.find((g) => g.name === field);
+        if (f)
+            f.name = x.answer.slice("rename:".length);
+    }
+    for (const x of answered(plan, "removedEntity")) {
+        if (!x.answer.startsWith("rename:"))
+            continue;
+        const from = subject(x.id).entity;
+        const to = x.answer.slice("rename:".length);
+        const e = copy.entities.find((y) => y.name === from);
+        if (!e)
+            continue;
+        e.name = to;
+        const target = after.entities.find((y) => y.name === to);
+        if (target === null || target === void 0 ? void 0 : target.table)
+            e.table = target.table;
+        else
+            delete e.table;
+        for (const r of (_c = copy.relationships) !== null && _c !== void 0 ? _c : []) {
+            if (r.from === from)
+                r.from = to;
+            if (r.to === from)
+                r.to = to;
+        }
+    }
+    return copy;
+}
+function renames(was, now) {
+    const same = (k) => was[k].length === now[k].length;
+    if (!same("tables") ||
+        !same("constraints") ||
+        !same("indexes") ||
+        !same("enums"))
+        throw new Error("Renaming changed the schema's shape; this rename can't be rendered.");
+    const out = [];
+    was.tables.forEach((t, i) => {
+        const n = now.tables[i];
+        if (t.name !== n.name)
+            out.push(`ALTER TABLE ${(0, _1.q)(t.name)} RENAME TO ${(0, _1.q)(n.name)}`);
+        t.columns.forEach((c, j) => {
+            const nc = n.columns[j];
+            if (c.name !== nc.name)
+                out.push(`ALTER TABLE ${(0, _1.q)(n.name)} RENAME COLUMN ${(0, _1.q)(c.name)} TO ${(0, _1.q)(nc.name)}`);
+            if (c.serial && t.name !== n.name)
+                out.push(`ALTER SEQUENCE ${(0, _1.q)(`${t.name}_${c.name}_seq`)} RENAME TO ${(0, _1.q)(`${n.name}_${nc.name}_seq`)}`);
+        });
+    });
+    was.constraints.forEach((c, i) => {
+        const n = now.constraints[i];
+        if (c.name !== n.name)
+            out.push(`ALTER TABLE ${(0, _1.q)(n.table)} RENAME CONSTRAINT ${(0, _1.q)(c.name)} TO ${(0, _1.q)(n.name)}`);
+    });
+    was.indexes.forEach((x, i) => {
+        if (x.name !== now.indexes[i].name)
+            out.push(`ALTER INDEX "public".${(0, _1.q)(x.name)} RENAME TO ${(0, _1.q)(now.indexes[i].name)}`);
+    });
+    was.enums.forEach((e, i) => {
+        if (e.name !== now.enums[i].name)
+            out.push(`ALTER TYPE "public".${(0, _1.q)(e.name)} RENAME TO ${(0, _1.q)(now.enums[i].name)}`);
+    });
+    return out;
+}
+const nullableSql = (c) => `${(0, _1.q)(c.name)} ${c.type}${c.default === undefined ? "" : ` DEFAULT ${c.default}`}`;
+/** Missing from the other model, or present under another name or definition. */
+const changed = (x, y) => !y || x.name !== y.name || x.body !== y.body || x.unique !== y.unique;
+/** The enum type name in a column type like "public"."contact_status_enum". */
+const typeOf = (t) => { var _a; return ((_a = t.match(/^"public"\."(.+)"$/)) !== null && _a !== void 0 ? _a : [])[1]; };
+function changeDdl(before, after, plan) {
+    const renamed = applyRenames(before, after, plan);
+    const was = (0, _1.schemaModel)((0, apsorc_parser_1.parseApsorcV2)(before));
+    const R = (0, _1.schemaModel)((0, apsorc_parser_1.parseApsorcV2)(renamed));
+    const A = (0, _1.schemaModel)((0, apsorc_parser_1.parseApsorcV2)(after));
+    const table = (entity, schema = after) => {
+        const e = schema.entities.find((x) => x.name === entity);
+        if (!e)
+            throw new Error(`No entity ${entity}`);
+        return (0, _1.tableName)(e);
+    };
+    const up = renames(was, R);
+    const later = [];
+    const rTables = new Map(R.tables.map((t) => [t.name, t]));
+    const aTables = new Map(A.tables.map((t) => [t.name, t]));
+    const rCons = new Map(R.constraints.map((c) => [c.key, c]));
+    const aCons = new Map(A.constraints.map((c) => [c.key, c]));
+    const rIdx = new Map(R.indexes.map((i) => [i.key, i]));
+    const aIdx = new Map(A.indexes.map((i) => [i.key, i]));
+    // Drop keys and indexes that go away or change. Foreign keys first.
+    for (const c of [...R.constraints].sort((a, b) => (a.kind === "fk" ? -1 : 0) - (b.kind === "fk" ? -1 : 0)))
+        if (changed(c, aCons.get(c.key)) &&
+            (c.kind === "fk" || aTables.has(c.table)))
+            up.push(`ALTER TABLE ${(0, _1.q)(c.table)} DROP CONSTRAINT ${(0, _1.q)(c.name)}`);
+    for (const i of R.indexes)
+        if (changed(i, aIdx.get(i.key)) && aTables.has(i.table))
+            up.push(`DROP INDEX "public".${(0, _1.q)(i.name)}`);
+    // Enum types: create new ones; swap changed ones through <name>_old.
+    const rEnums = new Map(R.enums.map((e) => [e.name, e]));
+    const swapped = new Set();
+    for (const e of A.enums) {
+        const old = rEnums.get(e.name);
+        if (!old)
+            up.push((0, _1.createTypeSql)(e));
+        else if (old.values.join(",") !== e.values.join(",")) {
+            up.push(`ALTER TYPE "public".${(0, _1.q)(e.name)} RENAME TO ${(0, _1.q)(`${e.name}_old`)}`, (0, _1.createTypeSql)(e));
+            swapped.add(e.name);
+            later.push(`DROP TYPE "public".${(0, _1.q)(`${e.name}_old`)}`);
+        }
+    }
+    // New tables, with their own primary and unique keys inline.
+    const createdInline = new Set();
+    for (const t of A.tables)
+        if (!rTables.has(t.name)) {
+            up.push((0, _1.createTableSql)(t, A.constraints));
+            for (const c of A.constraints)
+                if (c.table === t.name && c.kind !== "fk")
+                    createdInline.add(c.key);
+        }
+    // Columns on tables that stay.
+    const setNotNull = [];
+    const enumMap = new Map();
+    for (const x of answered(plan, "enumValue")) {
+        const { entity, field, value } = subject(x.id);
+        const key = `${table(entity)}.${field}`;
+        if (!enumMap.has(key))
+            enumMap.set(key, new Map());
+        enumMap.get(key).set(value, x.answer);
+    }
+    const casts = new Map(answered(plan, "cast").map((x) => {
+        const { entity, field } = subject(x.id);
+        return [`${table(entity)}.${field}`, x];
+    }));
+    for (const t of A.tables) {
+        const old = rTables.get(t.name);
+        if (!old)
+            continue;
+        for (const c of t.columns) {
+            const o = old.columns.find((x) => x.name === c.name);
+            const at = `ALTER TABLE ${(0, _1.q)(t.name)} ALTER COLUMN ${(0, _1.q)(c.name)}`;
+            if (!o) {
+                const needsData = c.notNull && c.default === undefined && !c.serial;
+                up.push(`ALTER TABLE ${(0, _1.q)(t.name)} ADD ${needsData ? nullableSql(c) : c.sql}`);
+                if (needsData)
+                    setNotNull.push(`${at} SET NOT NULL`);
+                continue;
+            }
+            const enumName = typeOf(c.type);
+            const retype = o.type !== c.type || (enumName && swapped.has(enumName));
+            if (retype) {
+                let using = `${(0, _1.q)(c.name)}::${c.type}`;
+                const map = enumMap.get(`${t.name}.${c.name}`);
+                const cast = casts.get(`${t.name}.${c.name}`);
+                if (enumName && (map === null || map === void 0 ? void 0 : map.size))
+                    using = `(CASE ${(0, _1.q)(c.name)}::text ${[...map]
+                        .map(([v, to]) => `WHEN ${(0, _1.literal)(v)} THEN ${(0, _1.literal)(to)}`)
+                        .join(" ")} ELSE ${(0, _1.q)(c.name)}::text END)::${c.type}`;
+                else if (enumName)
+                    using = `${(0, _1.q)(c.name)}::text::${c.type}`;
+                else if ((cast === null || cast === void 0 ? void 0 : cast.answer) === "sql")
+                    using = `(${cast.sql})`;
+                if (o.default !== undefined)
+                    up.push(`${at} DROP DEFAULT`);
+                up.push(`${at} TYPE ${c.type} USING ${using}`);
+                if (c.default !== undefined)
+                    setNotNull.push(`${at} SET DEFAULT ${c.default}`);
+            }
+            else if (o.default !== c.default) {
+                setNotNull.push(c.default === undefined
+                    ? `${at} DROP DEFAULT`
+                    : `${at} SET DEFAULT ${c.default}`);
+            }
+            if (!o.notNull && c.notNull)
+                setNotNull.push(`${at} SET NOT NULL`);
+            if (o.notNull && !c.notNull)
+                up.push(`${at} DROP NOT NULL`);
+        }
+    }
+    // Data: split, move, copied links, backfills.
+    for (const x of answered(plan, "removedField")) {
+        const { entity, field } = subject(x.id);
+        const t = table(entity);
+        if (x.answer.startsWith("split:") && typeof x.sql === "object") {
+            const sets = x
+                .answer.slice("split:".length)
+                .split(",")
+                .map((f) => `${(0, _1.q)(f)} = (${x.sql[f]})`);
+            up.push(`UPDATE ${(0, _1.q)(t)} SET ${sets.join(", ")}`);
+        }
+        if (x.answer.startsWith("move:")) {
+            const [toEntity, toField] = x.answer.slice("move:".length).split(".");
+            const target = table(toEntity);
+            const fk = A.constraints.find((c) => c.kind === "fk" && c.table === target && c.references === t);
+            if (!fk)
+                throw new Error(`${toEntity} has no foreign key to ${entity}, so ${field} can't move there.`);
+            up.push(`INSERT INTO ${(0, _1.q)(target)} (${(0, _1.q)(toField)}, ${(0, _1.q)(fk.columns[0])}) SELECT ${(0, _1.q)(field)}, "id" FROM ${(0, _1.q)(t)} WHERE ${(0, _1.q)(field)} IS NOT NULL`);
+        }
+    }
+    for (const x of answered(plan, "relation")) {
+        if (x.answer !== "copy-links")
+            continue;
+        const { entity, field: target } = subject(x.id);
+        const from = table(entity);
+        const to = table(target);
+        const fk = R.constraints.find((c) => c.kind === "fk" && c.table === from && c.references === to);
+        const joinFks = A.constraints.filter((c) => c.kind === "fk" && !rTables.has(c.table));
+        const join = joinFks.find((c) => c.references === from &&
+            joinFks.some((d) => d.table === c.table && d.references === to));
+        const other = join &&
+            joinFks.find((d) => d.table === join.table && d.references === to);
+        if (!fk || !join || !other)
+            throw new Error(`Can't find where ${entity}'s links to ${target} go.`);
+        up.push(`INSERT INTO ${(0, _1.q)(join.table)} (${(0, _1.q)(join.columns[0])}, ${(0, _1.q)(other.columns[0])}) SELECT "id", ${(0, _1.q)(fk.columns[0])} FROM ${(0, _1.q)(from)} WHERE ${(0, _1.q)(fk.columns[0])} IS NOT NULL`);
+    }
+    for (const x of answered(plan, "backfill")) {
+        const { entity, field } = subject(x.id);
+        const value = x.answer === "sql" ? `(${x.sql})` : (0, _1.literal)(x.answer);
+        up.push(`UPDATE ${(0, _1.q)(table(entity))} SET ${(0, _1.q)(field)} = ${value} WHERE ${(0, _1.q)(field)} IS NULL`);
+    }
+    up.push(...setNotNull);
+    // Drop what is gone: columns, tables, enum types.
+    for (const t of R.tables) {
+        const now = aTables.get(t.name);
+        if (!now)
+            continue;
+        for (const c of t.columns)
+            if (!now.columns.some((x) => x.name === c.name))
+                up.push(`ALTER TABLE ${(0, _1.q)(t.name)} DROP COLUMN ${(0, _1.q)(c.name)}`);
+    }
+    for (const t of R.tables)
+        if (!aTables.has(t.name))
+            up.push(`DROP TABLE ${(0, _1.q)(t.name)}`);
+    up.push(...later);
+    for (const e of R.enums)
+        if (!A.enums.some((x) => x.name === e.name))
+            up.push(`DROP TYPE "public".${(0, _1.q)(e.name)}`);
+    // New keys and indexes, foreign keys last.
+    const add = (c) => changed(c, rCons.get(c.key)) && !createdInline.has(c.key);
+    for (const c of A.constraints)
+        if (c.kind !== "fk" && add(c))
+            up.push((0, _1.addConstraintSql)(c));
+    for (const i of A.indexes)
+        if (changed(i, rIdx.get(i.key)))
+            up.push((0, _1.createIndexSql)(i));
+    for (const c of A.constraints)
+        if (c.kind === "fk" && add(c))
+            up.push((0, _1.addConstraintSql)(c));
+    return { up };
+}
+exports.changeDdl = changeDdl;
+/**
+ * The reverse migration: the plan from the new schema back to the deployed
+ * one, answered from the forward answers. Renames invert, added fields drop,
+ * removed enum values map back, a split rejoins, and data that moved (to a
+ * new table, or into many-to-many links) is copied back. Anything left
+ * unanswered is reported instead of guessed.
+ */
+function downDdl(before, after, plan) {
+    const fwd = new Map(plan.questions.filter((x) => x.answer).map((x) => [x.id, x]));
+    const entityRenamedFrom = new Map(answered(plan, "removedEntity")
+        .filter((x) => x.answer.startsWith("rename:"))
+        .map((x) => [x.answer.slice("rename:".length), subject(x.id).entity]));
+    const forwardEntity = (name) => { var _a, _b; return (_b = (_a = [...entityRenamedFrom].find(([, old]) => old === name)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : name; };
+    const nowTable = (entity) => (0, _1.tableName)(after.entities.find((e) => e.name === entity));
+    const A = (0, _1.schemaModel)((0, apsorc_parser_1.parseApsorcV2)(after));
+    const B = (0, _1.schemaModel)((0, apsorc_parser_1.parseApsorcV2)(before));
+    const answer = (x) => {
+        var _a;
+        const { entity, field, value } = subject(x.id);
+        if (x.kind === "removedEntity") {
+            const old = entityRenamedFrom.get(entity);
+            return { answer: old ? `rename:${old}` : "drop" };
+        }
+        if (x.kind === "removedField") {
+            const renamedFrom = [...fwd.values()].find((f) => f.kind === "removedField" &&
+                f.answer === `rename:${field}` &&
+                forwardEntity(subject(f.id).entity) === entity);
+            return {
+                answer: renamedFrom
+                    ? `rename:${subject(renamedFrom.id).field}`
+                    : "drop",
+            };
+        }
+        if (x.kind === "enumValue") {
+            const from = [...fwd.values()].find((f) => f.kind === "enumValue" &&
+                f.answer === value &&
+                subject(f.id).field === field);
+            return from && { answer: subject(from.id).value };
+        }
+        if (x.kind === "cast")
+            return { answer: "cast" };
+        if (x.kind === "relation")
+            return { answer: "drop-links" };
+        if (x.kind === "backfill") {
+            const split = fwd.get(`field:${forwardEntity(entity)}.${field}`);
+            if ((_a = split === null || split === void 0 ? void 0 : split.answer) === null || _a === void 0 ? void 0 : _a.startsWith("split:")) {
+                const parts = split.answer
+                    .slice("split:".length)
+                    .split(",")
+                    .map((p) => (0, _1.q)(p));
+                return { answer: "sql", sql: `concat_ws(' ', ${parts.join(", ")})` };
+            }
+        }
+        return undefined;
+    };
+    let rev = (0, plan_1.planMigration)(after, before);
+    for (let round = 0; round < 3; round++) {
+        for (const x of rev.questions)
+            if (!x.answer)
+                Object.assign(x, answer(x));
+        rev = (0, plan_1.planMigration)(after, before, rev);
+    }
+    // Data the forward migration moved out of a column comes back from where it went.
+    const extra = [];
+    for (const x of answered(plan, "removedField")) {
+        if (!x.answer.startsWith("move:"))
+            continue;
+        const { entity, field } = subject(x.id);
+        const [toEntity, toField] = x.answer.slice("move:".length).split(".");
+        const from = nowTable(entity);
+        const to = nowTable(toEntity);
+        const fk = A.constraints.find((c) => c.kind === "fk" && c.table === to && c.references === from);
+        extra.push({
+            id: `backfill:${entity}.${field}`,
+            kind: "backfill",
+            subject: `restore ${field} from ${toEntity}`,
+            options: ["sql"],
+            answer: "sql",
+            sql: `SELECT ${(0, _1.q)(toField)} FROM ${(0, _1.q)(to)} x WHERE x.${(0, _1.q)(fk.columns[0])} = ${(0, _1.q)(from)}."id" ORDER BY x."id" LIMIT 1`,
+        });
+    }
+    for (const x of answered(plan, "relation")) {
+        if (x.answer !== "copy-links")
+            continue;
+        const { entity, field: target } = subject(x.id);
+        const from = nowTable(entity);
+        const to = nowTable(target);
+        const fk = B.constraints.find((c) => c.kind === "fk" && c.table === from && c.references === to);
+        const joinFks = A.constraints.filter((c) => c.kind === "fk" && !B.tables.some((t) => t.name === c.table));
+        const own = joinFks.find((c) => c.references === from &&
+            joinFks.some((d) => d.table === c.table && d.references === to));
+        const other = joinFks.find((d) => d.table === own.table && d.references === to);
+        extra.push({
+            id: `backfill:${entity}.${fk.columns[0]}`,
+            kind: "backfill",
+            subject: `restore ${fk.columns[0]} from ${own.table}`,
+            options: ["sql"],
+            answer: "sql",
+            sql: `SELECT j.${(0, _1.q)(other.columns[0])} FROM ${(0, _1.q)(own.table)} j WHERE j.${(0, _1.q)(own.columns[0])} = ${(0, _1.q)(from)}."id" LIMIT 1`,
+        });
+    }
+    const open = (0, plan_1.openQuestions)(rev);
+    if (open.length > 0)
+        return { irreversible: open.map((x) => `${x.id}: ${x.subject}`) };
+    return {
+        down: changeDdl(after, before, {
+            ...rev,
+            questions: [...rev.questions, ...extra],
+        }).up,
+    };
+}
+exports.downDdl = downDdl;

package/dist/lib/ddl/index.d.ts

@@ -0,0 +1,80 @@
+import { Entity } from "../types/entity";
+import { ComputedField } from "../types/field";
+import { RelationshipMap } from "../types/relationship";
+export declare const constraintName: {
+    primaryKey: (t: string, cols: string[]) => string;
+    unique: (t: string, cols: string[]) => string;
+    relation: (t: string, cols: string[]) => string;
+    foreignKey: (t: string, cols: string[]) => string;
+    index: (t: string, cols: string[]) => string;
+};
+export declare const q: (name: string) => string;
+export declare const literal: (v: string) => string;
+export declare const tableName: (e: Entity) => string;
+export declare const enumTypeName: (table: string, column: string) => string;
+export interface ColumnSpec {
+    /** Column SQL without constraints: name, type, NOT NULL, DEFAULT. */
+    sql: string;
+    type: string;
+    notNull: boolean;
+    default?: string;
+    unique: boolean;
+    index: boolean;
+}
+/** One column as its entity template declares it. */
+export declare function columnSpec(table: string, f: ComputedField): ColumnSpec;
+export interface SchemaInput {
+    entities: Entity[];
+    relationshipMap: RelationshipMap;
+}
+export interface ModelColumn {
+    name: string;
+    /** The column as CREATE TABLE writes it. */
+    sql: string;
+    type: string;
+    notNull: boolean;
+    default?: string;
+    /** A SERIAL id, whose default is the table's id sequence. */
+    serial?: boolean;
+}
+export interface ModelTable {
+    name: string;
+    columns: ModelColumn[];
+}
+export interface ModelConstraint {
+    /** Identity independent of the name: kind, table, columns (and target). */
+    key: string;
+    name: string;
+    table: string;
+    kind: "pk" | "unique" | "fk";
+    columns: string[];
+    /** Everything after CONSTRAINT "name". */
+    body: string;
+    references?: string;
+}
+export interface ModelIndex {
+    key: string;
+    name: string;
+    table: string;
+    columns: string[];
+    unique: boolean;
+}
+export interface ModelEnum {
+    name: string;
+    values: string[];
+}
+/** Every object a schema creates, in creation order. */
+export interface Model {
+    extensions: string[];
+    enums: ModelEnum[];
+    tables: ModelTable[];
+    constraints: ModelConstraint[];
+    indexes: ModelIndex[];
+}
+export declare function schemaModel(input: SchemaInput): Model;
+export declare const createTypeSql: (e: ModelEnum) => string;
+export declare const createIndexSql: (i: ModelIndex) => string;
+export declare const addConstraintSql: (c: ModelConstraint) => string;
+export declare const createTableSql: (t: ModelTable, constraints: ModelConstraint[]) => string;
+/** CREATE statements for every enum type, table, index and foreign key. */
+export declare function schemaDdl(input: SchemaInput): string[];