@minnowdb/core 0.0.1 → 0.1.0

package/dist/engine/schema.js

@@ -0,0 +1,709 @@
+import { validateColumnDefault, validateEnumValues, } from "../storage/index.js";
+import { compileCheckExpression, expressionColumns } from "./query.js";
+/**
+ * The constraint name `migrate()` gives a declared relation. It matches the name the SQL parser
+ * derives for an unnamed inline REFERENCES, so a table built either way has the same catalog.
+ */
+export function foreignKeyName(tableName, columnName) {
+    return `${tableName}_${columnName}_fkey`;
+}
+function defaultSpecFromArg(type, value) {
+    switch (type) {
+        case "datetime":
+            if (value !== "now")
+                throw new TypeError('Datetime columns default with "now"');
+            return { kind: "now" };
+        case "string":
+            if (typeof value !== "string")
+                throw new TypeError("Default literal must be a string");
+            return { kind: "literal", value };
+        case "number":
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw new TypeError("Default literal must be a finite number");
+            }
+            return { kind: "literal", value };
+        case "boolean":
+            if (typeof value !== "boolean")
+                throw new TypeError("Default literal must be a boolean");
+            return { kind: "literal", value };
+    }
+}
+function createColumn(type, state = {}) {
+    const base = {
+        kind: "column",
+        type,
+        isNullable: (state.isNullable ?? false),
+        isUnique: (state.isUnique ?? false),
+        hasDefault: (state.defaultSpec !== undefined || state.defaultFn !== undefined),
+        ...(state.defaultSpec === undefined ? {} : { defaultSpec: state.defaultSpec }),
+        ...(state.defaultFn === undefined
+            ? {}
+            : { defaultFn: state.defaultFn }),
+        ...(state.renamedFromName === undefined ? {} : { renamedFromName: state.renamedFromName }),
+        ...(state.reference === undefined ? {} : { reference: state.reference }),
+        ...(state.enumValues === undefined ? {} : { enumValues: state.enumValues }),
+        ...(state.backfillValue === undefined
+            ? {}
+            : { backfillValue: state.backfillValue }),
+    };
+    return {
+        ...base,
+        nullable: () => createColumn(type, { ...state, isNullable: true }),
+        unique: () => createColumn(type, { ...state, isUnique: true }),
+        renamedFrom: (name) => createColumn(type, { ...state, renamedFromName: name }),
+        backfill: (value) => createColumn(type, { ...state, backfillValue: value }),
+        references: (table, referencedColumn, options = {}) => createColumn(type, {
+            ...state,
+            reference: {
+                table,
+                column: referencedColumn,
+                onDelete: options.onDelete ?? "restrict",
+            },
+        }),
+        default: ((value) => {
+            // A declared default is one thing: a function replaces any spec and vice versa.
+            const cleared = { ...state };
+            delete cleared.defaultSpec;
+            delete cleared.defaultFn;
+            return typeof value === "function"
+                ? createColumn(type, { ...cleared, defaultFn: value })
+                : createColumn(type, { ...cleared, defaultSpec: defaultSpecFromArg(type, value) });
+        }),
+        autoIncrement: (() => {
+            if (type !== "number") {
+                throw new TypeError("Auto-increment requires a number column");
+            }
+            const cleared = { ...state };
+            delete cleared.defaultFn;
+            return createColumn(type, { ...cleared, defaultSpec: { kind: "autoincrement" } });
+        }),
+    };
+}
+/**
+ * Rebuilds a column carrying an exact default spec — the wire layer's escape hatch, since the
+ * public `.default()` interprets "now" on datetime columns and cannot express auto-increment.
+ */
+export function columnWithDefaultSpec(base, spec) {
+    return createColumn(base.type, {
+        isNullable: base.isNullable,
+        isUnique: base.isUnique,
+        ...(base.renamedFromName === undefined ? {} : { renamedFromName: base.renamedFromName }),
+        ...(base.reference === undefined ? {} : { reference: base.reference }),
+        ...(base.enumValues === undefined ? {} : { enumValues: base.enumValues }),
+        defaultSpec: spec,
+    });
+}
+export const column = {
+    boolean: () => createColumn("boolean"),
+    number: () => createColumn("number"),
+    string: () => createColumn("string"),
+    datetime: () => createColumn("datetime"),
+    /**
+     * A string column restricted to a closed set of values, typed as their literal union:
+     *
+     * ```ts
+     * status: column.enum(["draft", "published", "archived"]).default("draft")
+     * ```
+     *
+     * Selects return `"draft" | "published" | "archived"` and inserts accept nothing else; every
+     * write path also validates membership at runtime. Physically the column is a plain string
+     * column, so migrations may add values or relax the column to `column.string()`, but never
+     * remove values — existing rows could already hold them.
+     */
+    enum: (values) => createColumn("string", { enumValues: validateEnumValues(values, "enum column") }),
+};
+export function table(name, columns, options = {}) {
+    const entries = Object.entries(columns);
+    if (entries.length === 0)
+        throw new TypeError(`Table ${name} needs at least one column`);
+    const uniqueColumns = entries.filter(([, definition]) => definition.isUnique);
+    if (uniqueColumns.length > 1) {
+        throw new TypeError(`Table ${name} may name at most one unique column`);
+    }
+    const uniqueEntry = uniqueColumns[0];
+    if (uniqueEntry?.[1].isNullable === true) {
+        throw new TypeError(`Table ${name} unique column must not be nullable: ${uniqueEntry[0]}`);
+    }
+    for (const [columnName, definition] of entries) {
+        if (definition.defaultFn !== undefined && definition.isNullable) {
+            throw new TypeError(`Defaults require a non-nullable column: ${columnName}`);
+        }
+        const backfill = definition.backfillValue;
+        if (backfill !== undefined && typeof backfill !== "function") {
+            const matches = definition.type === "datetime"
+                ? backfill instanceof Date
+                : typeof backfill === definition.type;
+            if (!matches) {
+                throw new TypeError(`Backfill value must be a ${definition.type}: ${name}.${columnName}`);
+            }
+            if (definition.enumValues !== undefined &&
+                typeof backfill === "string" &&
+                !definition.enumValues.includes(backfill)) {
+                throw new TypeError(`Backfill value must be one of: ${definition.enumValues.join(", ")} (${name}.${columnName})`);
+            }
+        }
+        if (backfill !== undefined && definition.isNullable) {
+            throw new TypeError(`A nullable column needs no backfill: ${name}.${columnName}. Rows without it already read NULL.`);
+        }
+        if (definition.reference?.onDelete === "set null" && !definition.isNullable) {
+            throw new TypeError(`ON DELETE SET NULL requires a nullable column: ${name}.${columnName}`);
+        }
+        const spec = definition.defaultSpec;
+        if (spec === undefined)
+            continue;
+        validateColumnDefault({
+            name: columnName,
+            type: definition.type,
+            nullable: definition.isNullable,
+            isUniqueKey: definition.isUnique,
+            ...(definition.enumValues === undefined ? {} : { enumValues: definition.enumValues }),
+        }, spec);
+    }
+    const checks = options.checks ?? [];
+    const checkNames = new Set();
+    for (const check of checks) {
+        if (check.name.length === 0)
+            throw new TypeError(`Table ${name} has an unnamed CHECK`);
+        if (checkNames.has(check.name)) {
+            throw new TypeError(`Duplicate CHECK in table ${name}: ${check.name}`);
+        }
+        checkNames.add(check.name);
+        if (check.sql.trim().length === 0) {
+            throw new TypeError(`CHECK ${check.name} in table ${name} has no expression`);
+        }
+    }
+    return {
+        kind: "table",
+        name,
+        columns,
+        checks,
+        "~standard": {
+            version: 1,
+            vendor: "minnow",
+            validate(value) {
+                if (typeof value !== "object" || value === null) {
+                    return { issues: [{ message: "A row must be an object", path: [] }] };
+                }
+                const row = value;
+                const issues = [];
+                for (const [columnName, definition] of entries) {
+                    const columnValue = row[columnName];
+                    if (columnValue === undefined || columnValue === null) {
+                        // A default-bearing column may be omitted — the engine (or the facade, for
+                        // function defaults) fills it at insert time.
+                        if (!definition.isNullable &&
+                            definition.defaultSpec === undefined &&
+                            definition.defaultFn === undefined) {
+                            issues.push({ message: `Missing non-nullable column`, path: [columnName] });
+                        }
+                        continue;
+                    }
+                    const matches = definition.type === "datetime"
+                        ? columnValue instanceof Date
+                        : typeof columnValue === definition.type;
+                    if (!matches) {
+                        issues.push({ message: `Expected ${definition.type}`, path: [columnName] });
+                    }
+                    else if (definition.enumValues !== undefined &&
+                        typeof columnValue === "string" &&
+                        !definition.enumValues.includes(columnValue)) {
+                        issues.push({
+                            message: `Expected one of: ${definition.enumValues.join(", ")}`,
+                            path: [columnName],
+                        });
+                    }
+                }
+                for (const key of Object.keys(row)) {
+                    if (!(key in columns))
+                        issues.push({ message: "Unknown column", path: [key] });
+                }
+                return issues.length > 0 ? { issues } : { value: row };
+            },
+        },
+    };
+}
+/**
+ * The FOREIGN KEY constraints a table declares, in column order. This is the single derivation
+ * of "what relations does this table have" — `planMigration` diffs against it and `migrate()`
+ * creates from it, so the two can never disagree.
+ */
+export function declaredForeignKeys(definition) {
+    const keys = [];
+    for (const [columnName, columnDefinition] of Object.entries(definition.columns)) {
+        const reference = columnDefinition.reference;
+        if (reference === undefined)
+            continue;
+        keys.push({
+            name: foreignKeyName(definition.name, columnName),
+            column: columnName,
+            parentTable: reference.table,
+            parentColumn: reference.column,
+            onDelete: reference.onDelete,
+        });
+    }
+    return keys;
+}
+/**
+ * Declares a view. Its columns use the same builders tables use, so a view row types exactly like
+ * a table row — but a view is read-only, and the typed facade will not let a write name one.
+ *
+ * ```ts
+ * const activeCustomers = view("active_customers", {
+ *   sql: `SELECT customer_id, name FROM customers WHERE status = 'active'`,
+ *   columns: { customer_id: column.number(), name: column.string() },
+ * });
+ * ```
+ */
+export function view(name, definition) {
+    const entries = Object.entries(definition.columns);
+    if (entries.length === 0)
+        throw new TypeError(`View ${name} needs at least one column`);
+    if (definition.sql.trim().length === 0)
+        throw new TypeError(`View ${name} has no query`);
+    for (const [columnName, columnDefinition] of entries) {
+        if (columnDefinition.isUnique) {
+            throw new TypeError(`A view column cannot be a unique key: ${name}.${columnName}`);
+        }
+        if (columnDefinition.defaultSpec !== undefined || columnDefinition.defaultFn !== undefined) {
+            throw new TypeError(`A view column cannot have a default: ${name}.${columnName}`);
+        }
+    }
+    return { kind: "view", name, sql: definition.sql, columns: definition.columns };
+}
+export function schema(tables, options = {}) {
+    const views = (options.views ?? []);
+    const names = new Set();
+    for (const definition of tables) {
+        if (names.has(definition.name)) {
+            throw new TypeError(`Duplicate table in schema: ${definition.name}`);
+        }
+        names.add(definition.name);
+    }
+    for (const definition of views) {
+        if (names.has(definition.name)) {
+            throw new TypeError(`Duplicate name in schema: ${definition.name}`);
+        }
+        names.add(definition.name);
+    }
+    for (const definition of tables) {
+        for (const [columnName, columnDefinition] of Object.entries(definition.columns)) {
+            const reference = columnDefinition.reference;
+            if (reference === undefined)
+                continue;
+            const target = tables.find(({ name }) => name === reference.table);
+            if (target === undefined || !(reference.column in target.columns)) {
+                throw new TypeError(`Relation target does not exist: ${definition.name}.${columnName} -> ${reference.table}.${reference.column}`);
+            }
+        }
+    }
+    return { kind: "schema", tables, views };
+}
+/**
+ * Views are derived: nothing is stored under one, so a body change is a replace rather than a
+ * rewrite and needs none of the proofs a table alteration needs.
+ *
+ * Within the set of views a migration created, the schema is authoritative — removing a
+ * declaration drops the view. Outside it nothing is touched: a view created with `CREATE VIEW`,
+ * or one written before ownership was recorded, is not any schema's to remove. That is the
+ * difference between a declaration being the source of truth and a declaration being allowed to
+ * destroy things it never made.
+ */
+function planViewSteps(catalog, definition, steps) {
+    const tableNames = new Set(catalog.tables.map(({ name }) => name));
+    const existing = new Map(catalog.views.map((record) => [record.name, record]));
+    const declared = new Set(definition.views.map(({ name }) => name));
+    for (const viewDefinition of definition.views) {
+        if (tableNames.has(viewDefinition.name)) {
+            throw new TypeError(`A table already exists with this name: ${viewDefinition.name}`);
+        }
+        if (existing.get(viewDefinition.name)?.sql === viewDefinition.sql)
+            continue;
+        steps.push({ kind: "replace-view", view: viewDefinition });
+    }
+    for (const record of catalog.views) {
+        if (declared.has(record.name) || !record.managed)
+            continue;
+        steps.push({ kind: "drop-view", viewName: record.name });
+    }
+}
+/**
+ * Creation order, so a table is created after the tables it references. A FOREIGN KEY names a
+ * parent that must already exist, which would otherwise make a schema fail purely because its
+ * tables were listed child-first. Declaration order is preserved among tables that do not
+ * constrain each other, and a reference cycle (or a self-reference, which the engine allows)
+ * falls back to declaration order rather than failing here — the engine still has the final say.
+ */
+function orderedForCreation(tables) {
+    const byName = new Map(tables.map((definition) => [definition.name, definition]));
+    const ordered = [];
+    const state = new Map();
+    const visit = (definition) => {
+        const status = state.get(definition.name);
+        if (status !== undefined)
+            return; // done, or a cycle we decline to reorder
+        state.set(definition.name, "visiting");
+        for (const key of declaredForeignKeys(definition)) {
+            const parent = byName.get(key.parentTable);
+            if (parent !== undefined && parent !== definition)
+                visit(parent);
+        }
+        state.set(definition.name, "done");
+        ordered.push(definition);
+    };
+    for (const definition of tables)
+        visit(definition);
+    return ordered;
+}
+/**
+ * Whether a step destroys data a reader could still see. These are the steps `migrate()` refuses
+ * to apply unless the caller opts in, so that a schema file drifting out of sync cannot delete
+ * rows the next time an application opens.
+ */
+export function isDestructiveStep(step) {
+    return step.kind === "drop-column" || step.kind === "drop-table";
+}
+/**
+ * A column can stop being projected without rewriting anything, but not while something else in
+ * the catalog still points at it. Each of these would leave a constraint or key referring to a
+ * column no longer there, so the drop is refused rather than silently invalidating them.
+ */
+function assertColumnDroppable(record, column) {
+    const where = `${record.name}.${column.name}`;
+    if (record.uniqueKeyColumnId === column.id) {
+        throw new TypeError(`The unique key cannot be dropped: ${where}. Unique-key changes need the table recreated.`);
+    }
+    for (const key of record.foreignKeys) {
+        if (key.column === column.name) {
+            throw new TypeError(`FOREIGN KEY ${key.name} still uses this column: ${where}`);
+        }
+    }
+    for (const check of record.checks) {
+        let referenced;
+        try {
+            referenced = expressionColumns(compileCheckExpression(check.sql, check.name));
+        }
+        catch {
+            // A check the engine can no longer compile is not a licence to drop what it names.
+            throw new TypeError(`CHECK ${check.name} cannot be re-read, so ${where} is not droppable`);
+        }
+        if (referenced.includes(column.name)) {
+            throw new TypeError(`CHECK ${check.name} still uses this column: ${where}`);
+        }
+    }
+}
+/**
+ * Freezes a column's backfill. A generator runs exactly once — here, while the migration is being
+ * planned — so the catalog stores a value rather than a function and no two readers can disagree.
+ */
+function resolveBackfill(definition) {
+    const declared = definition.backfillValue;
+    if (declared === undefined)
+        return undefined;
+    return typeof declared === "function" ? declared() : declared;
+}
+/**
+ * Constraints on an existing table cannot change through a metadata-only step. Attaching a
+ * FOREIGN KEY or CHECK to a table that already holds rows would claim something about those rows
+ * that nobody has verified, and no validation scan exists; dropping one is refused for the mirror
+ * reason, so that a constraint never disappears because a schema file drifted. Both get the same
+ * discipline every other unprovable change gets: an explicit error naming the fix.
+ */
+function assertConstraintsUnchanged(record, definition) {
+    const describeKey = (key) => `${key.column} -> ${key.parentTable}.${key.parentColumn} ON DELETE ${key.onDelete}`;
+    const existingKeys = new Map(record.foreignKeys.map((key) => [key.name, key]));
+    const declaredKeys = new Map(declaredForeignKeys(definition).map((key) => [key.name, key]));
+    for (const [name, declared] of declaredKeys) {
+        const existing = existingKeys.get(name);
+        if (existing === undefined) {
+            throw new TypeError(`FOREIGN KEY cannot be added after creation: ${definition.name}.${declared.column}. ` +
+                `Existing rows are not known to satisfy it; recreate the table to add a relation.`);
+        }
+        if (describeKey(existing) !== describeKey(declared)) {
+            throw new TypeError(`FOREIGN KEY cannot change: ${definition.name}.${declared.column} is ` +
+                `${describeKey(existing)}, schema says ${describeKey(declared)}`);
+        }
+    }
+    for (const name of existingKeys.keys()) {
+        if (!declaredKeys.has(name)) {
+            throw new TypeError(`FOREIGN KEY cannot be dropped: ${definition.name} still has ${name}. ` +
+                `Declare the relation, or recreate the table without it.`);
+        }
+    }
+    const existingChecks = new Map(record.checks.map((check) => [check.name, check.sql]));
+    const declaredChecks = new Map(definition.checks.map((check) => [check.name, check.sql]));
+    for (const [name, sql] of declaredChecks) {
+        const existing = existingChecks.get(name);
+        if (existing === undefined) {
+            throw new TypeError(`CHECK cannot be added after creation: ${definition.name}.${name}. ` +
+                `Existing rows are not known to satisfy it; recreate the table to add a constraint.`);
+        }
+        if (existing !== sql) {
+            throw new TypeError(`CHECK cannot change: ${definition.name}.${name} is (${existing}), schema says (${sql})`);
+        }
+    }
+    for (const name of existingChecks.keys()) {
+        if (!declaredChecks.has(name)) {
+            throw new TypeError(`CHECK cannot be dropped: ${definition.name} still has ${name}. ` +
+                `Declare the constraint, or recreate the table without it.`);
+        }
+    }
+}
+export function planMigration(catalog, definition, options = {}) {
+    const steps = [];
+    const currentByName = new Map(catalog.tables.map((record) => [record.name, record]));
+    for (const tableDefinition of orderedForCreation(definition.tables)) {
+        const record = currentByName.get(tableDefinition.name);
+        if (record === undefined) {
+            steps.push({ kind: "create-table", table: tableDefinition });
+            continue;
+        }
+        const recordColumnsByName = new Map(record.columns.map((columnRecord) => [columnRecord.name, columnRecord]));
+        const definedNames = new Set(Object.keys(tableDefinition.columns));
+        const renameSources = new Set();
+        for (const [columnName, columnDefinition] of Object.entries(tableDefinition.columns)) {
+            const from = columnDefinition.renamedFromName;
+            let existing = recordColumnsByName.get(columnName);
+            if (existing === undefined && from !== undefined) {
+                const source = recordColumnsByName.get(from);
+                if (source !== undefined) {
+                    if (definedNames.has(from)) {
+                        throw new TypeError(`Rename source is still defined: ${tableDefinition.name}.${from}`);
+                    }
+                    steps.push({
+                        kind: "rename-column",
+                        tableName: tableDefinition.name,
+                        from,
+                        to: columnName,
+                    });
+                    renameSources.add(from);
+                    existing = source;
+                }
+            }
+            if (existing === undefined) {
+                const backfill = resolveBackfill(columnDefinition);
+                if (!columnDefinition.isNullable && backfill === undefined) {
+                    throw new TypeError(`Added columns must be nullable, or carry a backfill: ${tableDefinition.name}.${columnName}`);
+                }
+                if (columnDefinition.isUnique) {
+                    throw new TypeError(`Unique keys cannot be added after creation: ${tableDefinition.name}.${columnName}`);
+                }
+                steps.push({
+                    kind: "add-column",
+                    tableName: tableDefinition.name,
+                    columnName,
+                    definition: columnDefinition,
+                    ...(backfill === undefined ? {} : { backfill }),
+                });
+                continue;
+            }
+            if (existing.type !== columnDefinition.type) {
+                throw new TypeError(`Column types cannot change: ${tableDefinition.name}.${columnName} is ${existing.type}, schema says ${columnDefinition.type}`);
+            }
+            const existingEnum = existing.enumValues;
+            const definedEnum = columnDefinition.enumValues;
+            if (definedEnum !== undefined && existingEnum === undefined) {
+                throw new TypeError(`Plain string columns cannot tighten to an enum: ${tableDefinition.name}.${columnName}. Existing rows may hold values outside the set.`);
+            }
+            if (existingEnum !== undefined) {
+                if (definedEnum === undefined) {
+                    steps.push({
+                        kind: "widen-enum",
+                        tableName: tableDefinition.name,
+                        columnName,
+                        enumValues: null,
+                    });
+                }
+                else {
+                    const removed = existingEnum.filter((value) => !definedEnum.includes(value));
+                    if (removed.length > 0) {
+                        throw new TypeError(`Enum values cannot be removed: ${tableDefinition.name}.${columnName} drops ${removed.join(", ")}`);
+                    }
+                    if (definedEnum.some((value) => !existingEnum.includes(value))) {
+                        steps.push({
+                            kind: "widen-enum",
+                            tableName: tableDefinition.name,
+                            columnName,
+                            enumValues: [...definedEnum],
+                        });
+                    }
+                }
+            }
+            const existingIsKey = record.uniqueKeyColumnId === existing.id;
+            if (existingIsKey !== columnDefinition.isUnique) {
+                throw new TypeError(`Unique keys cannot change: ${tableDefinition.name}.${columnName}`);
+            }
+            if (existing.nullable && !columnDefinition.isNullable) {
+                steps.push({
+                    kind: "tighten-nullable",
+                    tableName: tableDefinition.name,
+                    columnName,
+                });
+            }
+            if (!existing.nullable && columnDefinition.isNullable) {
+                steps.push({
+                    kind: "widen-nullable",
+                    tableName: tableDefinition.name,
+                    columnName,
+                });
+            }
+            if (!columnDefaultsEqual(existing.defaultValue, columnDefinition.defaultSpec)) {
+                const wasAuto = existing.defaultValue?.kind === "autoincrement";
+                const isAuto = columnDefinition.defaultSpec?.kind === "autoincrement";
+                if (wasAuto !== isAuto) {
+                    // Adopting one seeds the counter past the largest key already stored; dropping one
+                    // simply stops generating. Neither rewrites a row.
+                    steps.push({
+                        kind: "set-auto-increment",
+                        tableName: tableDefinition.name,
+                        columnName,
+                        enabled: isAuto,
+                    });
+                    continue;
+                }
+                steps.push({
+                    kind: "alter-default",
+                    tableName: tableDefinition.name,
+                    columnName,
+                    defaultValue: columnDefinition.defaultSpec ?? null,
+                });
+            }
+        }
+        for (const columnRecord of record.columns) {
+            if (definedNames.has(columnRecord.name) || renameSources.has(columnRecord.name))
+                continue;
+            assertColumnDroppable(record, columnRecord);
+            steps.push({
+                kind: "drop-column",
+                tableName: tableDefinition.name,
+                columnName: columnRecord.name,
+            });
+        }
+        assertConstraintsUnchanged(record, tableDefinition);
+    }
+    if (options.schemaOwnsDatabase === true) {
+        const declaredTables = new Set(definition.tables.map(({ name }) => name));
+        for (const record of catalog.tables) {
+            // Only tables a migration created; see `managed`. Rows are at stake, so an undeclared
+            // table someone else made is never a migration's to remove.
+            if (declaredTables.has(record.name) || !record.managed)
+                continue;
+            steps.push({ kind: "drop-table", tableName: record.name });
+        }
+    }
+    planViewSteps(catalog, definition, steps);
+    return { steps };
+}
+/**
+ * A thin, fully typed handle over the existing batch APIs: inserts require every non-nullable
+ * column, updates exclude the unique key, and reads return the complete inferred row shape.
+ */
+export function typedTable(database, definition) {
+    const columnNames = Object.keys(definition.columns);
+    // Pads every schema column, so omitting a nullable one is an explicit null rather than a
+    // "Missing column" error from the engine; function defaults fill their omitted slots here,
+    // before the batch reaches the engine.
+    const pad = (rows) => rows.map((row) => Object.fromEntries(columnNames.map((name) => {
+        const value = row[name] ?? null;
+        const fill = definition.columns[name]?.defaultFn;
+        return [name, value === null && fill !== undefined ? fill() : value];
+    })));
+    return {
+        definition,
+        insert: (rows) => database.insertBatch(definition.name, pad(rows)),
+        upsert: (rows) => database.upsertBatch(definition.name, pad(rows)),
+        update: (input) => database.updateBatch(definition.name, {
+            keys: input.keys,
+            changes: input.changes,
+        }),
+        delete: (input) => database.deleteBatch(definition.name, { keys: input.keys }),
+        rows: async () => (await database.readTable(definition.name)),
+    };
+}
+/** Applies one table's alteration steps onto its current column records. */
+export function applyColumnSteps(record, steps, createId) {
+    const columns = structuredClone(record.columns);
+    for (const step of steps) {
+        if (step.kind === "rename-column") {
+            const target = columns.find(({ name }) => name === step.from);
+            if (target !== undefined)
+                target.name = step.to;
+            continue;
+        }
+        if (step.kind === "add-column") {
+            if (!columns.some(({ name }) => name === step.columnName)) {
+                columns.push({
+                    id: createId(),
+                    name: step.columnName,
+                    type: step.definition.type,
+                    // A backfill is what lets the column be non-nullable: every row has a value, either
+                    // written or substituted at read time.
+                    nullable: step.backfill === undefined ? true : step.definition.isNullable,
+                    ...(step.backfill === undefined ? {} : { backfill: step.backfill }),
+                    ...(step.definition.enumValues === undefined
+                        ? {}
+                        : { enumValues: [...step.definition.enumValues] }),
+                });
+            }
+            continue;
+        }
+        if (step.kind === "widen-enum") {
+            const target = columns.find(({ name }) => name === step.columnName);
+            if (target !== undefined) {
+                if (step.enumValues === null)
+                    delete target.enumValues;
+                else
+                    target.enumValues = [...step.enumValues];
+            }
+            continue;
+        }
+        if (step.kind === "widen-nullable") {
+            const target = columns.find(({ name }) => name === step.columnName);
+            if (target !== undefined)
+                target.nullable = true;
+            continue;
+        }
+        if (step.kind === "drop-column") {
+            // The column record goes; the stored blocks stay until compaction rewrites the segments
+            // that hold them, which is what keeps the drop a metadata step.
+            const index = columns.findIndex(({ name }) => name === step.columnName);
+            if (index !== -1)
+                columns.splice(index, 1);
+            continue;
+        }
+        if (step.kind === "tighten-nullable") {
+            // The proof happens before this runs; see MinnowDatabase#columnHoldsNull.
+            const target = columns.find(({ name }) => name === step.columnName);
+            if (target !== undefined)
+                target.nullable = false;
+            continue;
+        }
+        if (step.kind === "set-auto-increment") {
+            const target = columns.find(({ name }) => name === step.columnName);
+            if (target !== undefined) {
+                if (step.enabled)
+                    target.defaultValue = { kind: "autoincrement" };
+                else
+                    delete target.defaultValue;
+            }
+            continue;
+        }
+        if (step.kind === "alter-default") {
+            const target = columns.find(({ name }) => name === step.columnName);
+            if (target !== undefined) {
+                if (step.defaultValue === null)
+                    delete target.defaultValue;
+                else
+                    target.defaultValue = step.defaultValue;
+            }
+        }
+    }
+    return columns;
+}
+function columnDefaultsEqual(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    if (left.kind !== right.kind)
+        return false;
+    return left.kind !== "literal" || right.kind !== "literal" || left.value === right.value;
+}
+//# sourceMappingURL=schema.js.map