@primate/core 0.4.6 → 0.6.0

package/lib/private/db/With.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=With.js.map

package/lib/private/db/common.d.ts

@@ -0,0 +1,25 @@
+import type As from "#db/As";
+import type ReadArgs from "#db/ReadArgs";
+import type ReadRelationsArgs from "#db/ReadRelationsArgs";
+import type With from "#db/With";
+import type { Dict } from "@rcompat/type";
+import type { DataKey } from "pema";
+declare const UUID_TYPES: DataKey[];
+declare function generate_uuid(type: typeof UUID_TYPES[number]): string;
+declare function is_uuid_type(type: DataKey): type is typeof UUID_TYPES[number];
+declare const BASE: {
+    withed(args: ReadArgs & {
+        with?: With;
+    }): args is ReadRelationsArgs;
+    fields(base: string[] | undefined, ...add: (string | null)[]): string[] | undefined;
+    project(row: Dict, fields?: string[]): Dict;
+    expand(as: As, fields: string[] | undefined, relations: With): string[] | undefined;
+    generate_uuid: typeof generate_uuid;
+    is_uuid_type: typeof is_uuid_type;
+    BIGINT_STRING_TYPES: string[];
+    UNSIGNED_BIGINT_TYPES: string[];
+    INT_TYPES: string[];
+    UUID_TYPES: (keyof import("pema").DataType)[];
+};
+export default BASE;
+//# sourceMappingURL=common.d.ts.map

package/lib/private/db/common.js

@@ -0,0 +1,67 @@
+const UNSIGNED_BIGINT_TYPES = ["u64", "u128"];
+const SIGNED_BIGINT_TYPES = ["i128"];
+const BIGINT_STRING_TYPES = [...UNSIGNED_BIGINT_TYPES, ...SIGNED_BIGINT_TYPES];
+const INT_TYPES = ["u8", "u16", "u32", "i8", "i16", "i32"];
+const UUID_TYPES = ["uuid", "uuid_v4", "uuid_v7"];
+function uuid_v7() {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    const ts = BigInt(Date.now());
+    bytes[0] = Number((ts >> 40n) & 0xffn);
+    bytes[1] = Number((ts >> 32n) & 0xffn);
+    bytes[2] = Number((ts >> 24n) & 0xffn);
+    bytes[3] = Number((ts >> 16n) & 0xffn);
+    bytes[4] = Number((ts >> 8n) & 0xffn);
+    bytes[5] = Number(ts & 0xffn);
+    bytes[6] = (bytes[6] & 0x0f) | 0x70; // version 7
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant
+    const hex = bytes.toHex();
+    return (hex.slice(0, 8) + "-" +
+        hex.slice(8, 12) + "-" +
+        hex.slice(12, 16) + "-" +
+        hex.slice(16, 20) + "-" +
+        hex.slice(20));
+}
+function generate_uuid(type) {
+    if (type === "uuid_v4")
+        return crypto.randomUUID();
+    // "uuid" and "uuid_v7" both use v7 as the best native choice
+    return uuid_v7();
+}
+function is_uuid_type(type) {
+    return UUID_TYPES.includes(type);
+}
+const BASE = {
+    withed(args) {
+        return args.with !== undefined;
+    },
+    fields(base, ...add) {
+        if (base === undefined)
+            return undefined;
+        const set = new Set(base);
+        for (const f of add)
+            if (f !== null)
+                set.add(f);
+        return [...set];
+    },
+    project(row, fields) {
+        if (fields === undefined || fields.length === 0)
+            return { ...row };
+        const out = {};
+        for (const k of fields)
+            if (k in row)
+                out[k] = row[k];
+        return out;
+    },
+    expand(as, fields, relations) {
+        const fks = Object.values(relations).flatMap(r => r.reverse ? [r.fk] : []);
+        return BASE.fields(fields, as.pk, ...fks);
+    },
+    generate_uuid,
+    is_uuid_type,
+    BIGINT_STRING_TYPES,
+    UNSIGNED_BIGINT_TYPES,
+    INT_TYPES,
+    UUID_TYPES,
+};
+export default BASE;
+//# sourceMappingURL=common.js.map

package/lib/private/db/errors.d.ts

@@ -0,0 +1,104 @@
+declare function db_missing(): import("@rcompat/error").TemplateError;
+declare function store_directory_missing(): import("@rcompat/error").TemplateError;
+declare function store_directory_empty(): import("@rcompat/error").TemplateError;
+declare function store_name_required(): import("@rcompat/error").TemplateError;
+declare function unregistered_schema(): import("@rcompat/error").TemplateError;
+declare function record_not_found(field: string, value: string | number | bigint): import("@rcompat/error").TemplateError;
+declare function key_duplicate(key: string): import("@rcompat/error").TemplateError;
+declare function table_not_found(table: string): import("@rcompat/error").TemplateError;
+type RecordCountInvalidContext = "get" | "update" | "delete" | "count";
+declare function record_number_invalid(n: number, context: RecordCountInvalidContext): import("@rcompat/error").TemplateError;
+declare function return_invalid(got: unknown, expected: string, context: RecordCountInvalidContext): import("@rcompat/error").TemplateError;
+declare function pk_undefined(store: string): import("@rcompat/error").TemplateError;
+declare function pk_immutable(pk: string): import("@rcompat/error").TemplateError;
+declare function pk_duplicate(pk: string): import("@rcompat/error").TemplateError;
+declare function pk_invalid(pk: unknown): import("@rcompat/error").TemplateError;
+declare function pk_required(table: string): import("@rcompat/error").TemplateError;
+declare function pk_multiple_pks(first: string, second: string): import("@rcompat/error").TemplateError;
+declare function pk_invalid_type(datatype: string): import("@rcompat/error").TemplateError;
+type Context = "select" | "where" | "sort" | "insert" | "set" | "unbind";
+declare function field_unknown(field: string, context: Context): import("@rcompat/error").TemplateError;
+declare function field_duplicate(field: string, context: Context): import("@rcompat/error").TemplateError;
+declare function field_required(operator: string): import("@rcompat/error").TemplateError;
+declare function field_undefined(field: string, context: Context): import("@rcompat/error").TemplateError;
+declare function fields_unknown(fields: string[]): import("@rcompat/error").TemplateError;
+declare function null_not_allowed(field: string): import("@rcompat/error").TemplateError;
+declare function wrong_type(type: "string" | "number" | "bigint" | "boolean" | "url" | "date" | "blob", field: string, got: unknown, op?: string): import("@rcompat/error").TemplateError;
+declare function operator_unknown(field: string, operator: string): import("@rcompat/error").TemplateError;
+declare function operator_empty(field: string): import("@rcompat/error").TemplateError;
+declare function operator_scalar(field: string): import("@rcompat/error").TemplateError;
+declare function sort_empty(): import("@rcompat/error").TemplateError;
+declare function sort_invalid(): import("@rcompat/error").TemplateError;
+declare function sort_invalid_value(field: string, value: unknown): import("@rcompat/error").TemplateError;
+declare function select_empty(): import("@rcompat/error").TemplateError;
+declare function select_invalid(): import("@rcompat/error").TemplateError;
+declare function limit_invalid(): import("@rcompat/error").TemplateError;
+declare function select_invalid_value(index: number, x: unknown): import("@rcompat/error").TemplateError;
+declare function where_required(): import("@rcompat/error").TemplateError;
+declare function where_invalid(): import("@rcompat/error").TemplateError;
+declare function where_invalid_value(field: string, value: unknown): import("@rcompat/error").TemplateError;
+declare function set_empty(): import("@rcompat/error").TemplateError;
+declare function relation_unknown(relation: string): import("@rcompat/error").TemplateError;
+declare function relation_requires_pk(type: "target" | "parent"): import("@rcompat/error").TemplateError;
+declare function relation_conflicts_with_field(relation: string): import("@rcompat/error").TemplateError;
+declare function option_unknown(option: string): import("@rcompat/error").TemplateError;
+declare function identifier_invalid(identifier: string): import("@rcompat/error").TemplateError;
+declare function count_with_invalid(): import("@rcompat/error").TemplateError;
+declare function count_overflow(table: string, count: unknown): import("@rcompat/error").TemplateError;
+declare function migration_directory_missing(): import("@rcompat/error").TemplateError;
+declare function migration_store_conflict(message: string): import("@rcompat/error").TemplateError;
+declare function unapplied_migrations(): import("@rcompat/error").TemplateError;
+declare const errors: {
+    option_unknown: typeof option_unknown;
+    identifier_invalid: typeof identifier_invalid;
+    count_with_invalid: typeof count_with_invalid;
+    count_overflow: typeof count_overflow;
+    migration_directory_missing: typeof migration_directory_missing;
+    migration_store_conflict: typeof migration_store_conflict;
+    unapplied_migrations: typeof unapplied_migrations;
+    relation_unknown: typeof relation_unknown;
+    relation_requires_pk: typeof relation_requires_pk;
+    relation_conflicts_with_field: typeof relation_conflicts_with_field;
+    sort_empty: typeof sort_empty;
+    sort_invalid: typeof sort_invalid;
+    sort_invalid_value: typeof sort_invalid_value;
+    select_empty: typeof select_empty;
+    select_invalid: typeof select_invalid;
+    select_invalid_value: typeof select_invalid_value;
+    where_required: typeof where_required;
+    where_invalid: typeof where_invalid;
+    where_invalid_value: typeof where_invalid_value;
+    set_empty: typeof set_empty;
+    limit_invalid: typeof limit_invalid;
+    operator_unknown: typeof operator_unknown;
+    operator_empty: typeof operator_empty;
+    wrong_type: typeof wrong_type;
+    operator_scalar: typeof operator_scalar;
+    null_not_allowed: typeof null_not_allowed;
+    field_unknown: typeof field_unknown;
+    field_duplicate: typeof field_duplicate;
+    field_required: typeof field_required;
+    field_undefined: typeof field_undefined;
+    fields_unknown: typeof fields_unknown;
+    pk_undefined: typeof pk_undefined;
+    pk_immutable: typeof pk_immutable;
+    pk_duplicate: typeof pk_duplicate;
+    pk_invalid: typeof pk_invalid;
+    pk_required: typeof pk_required;
+    pk_multiple_pks: typeof pk_multiple_pks;
+    pk_invalid_type: typeof pk_invalid_type;
+    db_missing: typeof db_missing;
+    store_directory_missing: typeof store_directory_missing;
+    store_directory_empty: typeof store_directory_empty;
+    store_name_required: typeof store_name_required;
+    unregistered_schema: typeof unregistered_schema;
+    record_not_found: typeof record_not_found;
+    record_number_invalid: typeof record_number_invalid;
+    return_invalid: typeof return_invalid;
+    key_duplicate: typeof key_duplicate;
+    table_not_found: typeof table_not_found;
+};
+export type Code = keyof typeof errors;
+export declare const Code: { [K in Code]: K; };
+export default errors;
+//# sourceMappingURL=errors.d.ts.map

package/lib/private/db/errors.js

@@ -0,0 +1,237 @@
+import error from "@rcompat/error";
+const MAX_INT = Number.MAX_SAFE_INTEGER;
+const t = error.template;
+function kind_of(x) {
+    if (x === null)
+        return "null";
+    if (x instanceof Date)
+        return "Date";
+    if (x instanceof URL)
+        return "URL";
+    if (x instanceof Blob)
+        return "Blob";
+    return typeof x;
+}
+function db_missing() {
+    return t `database missing`;
+}
+function store_directory_missing() {
+    return t `store directory missing`;
+}
+function store_directory_empty() {
+    return t `store directory empty`;
+}
+function store_name_required() {
+    return t `store name required`;
+}
+function unregistered_schema() {
+    return t `no store registered for schema`;
+}
+function record_not_found(field, value) {
+    return t `no record with ${field} = ${value}`;
+}
+function key_duplicate(key) {
+    return t `key ${key} already exists`;
+}
+function table_not_found(table) {
+    return t `table ${table} not found`;
+}
+function record_number_invalid(n, context) {
+    return t `${context}: record number invalid (${n} instead of 1)`;
+}
+function return_invalid(got, expected, context) {
+    return t `${context} returned ${typeof got}, expected ${expected}`;
+}
+const STORE = error.coded({
+    db_missing,
+    store_directory_missing,
+    store_directory_empty,
+    store_name_required,
+    unregistered_schema,
+    record_not_found,
+    record_number_invalid,
+    return_invalid,
+    key_duplicate,
+    table_not_found,
+});
+function pk_undefined(store) {
+    return t `${store}: store has no primary key`;
+}
+function pk_immutable(pk) {
+    return t `primary key ${pk} cannot be updated`;
+}
+function pk_duplicate(pk) {
+    return t `primary key ${pk} already exists`;
+}
+function pk_invalid(pk) {
+    return t `pk value ${pk} (${kind_of(pk)}) does not match the expected type`;
+}
+function pk_required(table) {
+    return t `primary key is required but has generate=${false} in table ${table}`;
+}
+function pk_multiple_pks(first, second) {
+    return t `multiple primary keys: ${first}, ${second}`;
+}
+function pk_invalid_type(datatype) {
+    return t `primary key type ${datatype} not allowed; use unsigned integers or p.uuid`;
+}
+const PK = error.coded({
+    pk_undefined,
+    pk_immutable,
+    pk_duplicate,
+    pk_invalid,
+    pk_required,
+    pk_multiple_pks,
+    pk_invalid_type,
+});
+function field_unknown(field, context) {
+    return t `${field}: unknown field on ${context}`;
+}
+function field_duplicate(field, context) {
+    return t `${field}: duplicate field on ${context}`;
+}
+function field_required(operator) {
+    return t `${operator}: at least one field required`;
+}
+function field_undefined(field, context) {
+    return t `${field}: undefined value on ${context}`;
+}
+function fields_unknown(fields) {
+    return t `unknown fields ${fields}`;
+}
+const FIELD = error.coded({
+    field_unknown,
+    field_duplicate,
+    field_required,
+    field_undefined,
+    fields_unknown,
+});
+function null_not_allowed(field) {
+    return t `${field}: null not allowed`;
+}
+const NULL = error.coded({
+    null_not_allowed,
+});
+function wrong_type(type, field, got, op = "value") {
+    return t `${field}: ${op} requires ${type}, got ${kind_of(got)}`;
+}
+function operator_unknown(field, operator) {
+    return t `${field}: unknown operator ${operator}`;
+}
+function operator_empty(field) {
+    return t `${field}: empty operator`;
+}
+function operator_scalar(field) {
+    return t `${field}: operator requires scalar value`;
+}
+const OPERATOR = error.coded({
+    operator_unknown,
+    operator_empty,
+    wrong_type,
+    operator_scalar,
+});
+function sort_empty() {
+    return t `empty sort`;
+}
+function sort_invalid() {
+    return t `sort invalid`;
+}
+function sort_invalid_value(field, value) {
+    return t `${field}: invalid sort value, received ${kind_of(value)}`;
+}
+function select_empty() {
+    return t `empty select`;
+}
+function select_invalid() {
+    return t `invalid select`;
+}
+function limit_invalid() {
+    return t `invalid limit`;
+}
+function select_invalid_value(index, x) {
+    return t `select[${index}]: must be string, received ${kind_of(x)}`;
+}
+function where_required() {
+    return t `where required`;
+}
+function where_invalid() {
+    return t `where invalid`;
+}
+function where_invalid_value(field, value) {
+    return t `${field}: invalid where value, received ${kind_of(value)}`;
+}
+function set_empty() {
+    return t `empty set on update`;
+}
+const QUERY = error.coded({
+    sort_empty,
+    sort_invalid,
+    sort_invalid_value,
+    select_empty,
+    select_invalid,
+    select_invalid_value,
+    where_required,
+    where_invalid,
+    where_invalid_value,
+    set_empty,
+    limit_invalid,
+});
+function relation_unknown(relation) {
+    return t `unknown relation ${relation}`;
+}
+function relation_requires_pk(type) {
+    return t `relation loading requires ${type} primary key`;
+}
+function relation_conflicts_with_field(relation) {
+    return t `relation ${relation} conflicts with an existing schema field`;
+}
+const RELATION = error.coded({
+    relation_unknown,
+    relation_requires_pk,
+    relation_conflicts_with_field,
+});
+function option_unknown(option) {
+    return t `unknown option ${option}`;
+}
+function identifier_invalid(identifier) {
+    return t `invalid identifier ${identifier}`;
+}
+function count_with_invalid() {
+    return t `${"count"} and ${"with"} are mutually exclusive`;
+}
+function count_overflow(table, count) {
+    return t `${table}: count overflow, received ${count} (max ${MAX_INT})`;
+}
+function migration_directory_missing() {
+    return t `missing ${"migrations"} directory`;
+}
+function migration_store_conflict(message) {
+    return t `multiple migratable stores share the same table:\n${message}`;
+}
+function unapplied_migrations() {
+    return t `You have unapplied migrations.
+— Show migration status ${"npx primate migrate:status"}
+- Apply pending migrations ${"npx primate migrate:apply"}`;
+}
+const MISC = error.coded({
+    option_unknown,
+    identifier_invalid,
+    count_with_invalid,
+    count_overflow,
+    migration_directory_missing,
+    migration_store_conflict,
+    unapplied_migrations,
+});
+const errors = {
+    ...STORE,
+    ...PK,
+    ...FIELD,
+    ...NULL,
+    ...OPERATOR,
+    ...QUERY,
+    ...RELATION,
+    ...MISC,
+};
+export const Code = Object.fromEntries(Object.keys(errors).map(k => [k, k]));
+export default errors;
+//# sourceMappingURL=errors.js.map

package/lib/private/db/migrate/apply.d.ts

@@ -0,0 +1,2 @@
+export default function apply_migration(): Promise<void>;
+//# sourceMappingURL=apply.d.ts.map

package/lib/private/db/migrate/apply.js

@@ -0,0 +1,32 @@
+import E from "#db/errors";
+import store from "#db/migrate/store";
+import color from "@rcompat/cli/color";
+import print from "@rcompat/cli/print";
+import fs from "@rcompat/fs";
+export default async function apply_migration() {
+    const Migration = await store();
+    await Migration.table.create();
+    const last = await Migration.find({ limit: 1, sort: { id: "desc" } });
+    const last_id = last.length === 0 ? 0 : last[0].id;
+    const root = await fs.project.root();
+    const migrations_dir = root.join("migrations");
+    if (!await migrations_dir.exists())
+        throw E.migration_directory_missing();
+    const files = (await migrations_dir.files({ filter: /\d+-.*\.[jt]s$/ }))
+        .map(f => ({ file: f, n: parseInt(f.name.split("-")[0]) }))
+        .filter(({ n }) => n > last_id)
+        .toSorted((a, b) => a.n - b.n);
+    if (files.length === 0) {
+        print("No pending migrations.\n");
+        return;
+    }
+    for (const { file, n } of files) {
+        const { default: migration } = await import(file.path);
+        await migration(Migration.db);
+        await Migration.insert({ id: n, applied: new Date() });
+        print(`Applied migration ${color.bold(file.name)}.\n`);
+    }
+    const plural = files.length === 1 ? "" : "s";
+    print(`Done. Applied ${files.length} migration${plural}.\n`);
+}
+//# sourceMappingURL=apply.js.map

package/lib/private/db/migrate/bundle.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (contents: string) => Promise<any>;
+export default _default;
+//# sourceMappingURL=bundle.d.ts.map

package/lib/private/db/migrate/bundle.js

@@ -0,0 +1,22 @@
+import fs from "@rcompat/fs";
+import esbuild from "esbuild";
+export default async (contents) => {
+    const root = await fs.project.root();
+    const id = Date.now();
+    const entrypoint = root.join(`.migrate-in-${id}.js`);
+    const out = root.join(`.migrate-out-${id}.js`);
+    await entrypoint.write(contents);
+    esbuild.buildSync({
+        entryPoints: [entrypoint.path],
+        outfile: out.path,
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        tsconfig: root.join("tsconfig.json").path,
+    });
+    await entrypoint.remove();
+    const result = await out.import("default");
+    await out.remove();
+    return result;
+};
+//# sourceMappingURL=bundle.js.map

package/lib/private/db/migrate/create.d.ts

@@ -0,0 +1,2 @@
+export default function create_migration(desc: string): Promise<void>;
+//# sourceMappingURL=create.d.ts.map

package/lib/private/db/migrate/create.js

@@ -0,0 +1,154 @@
+import E from "#db/errors";
+import bundle from "#db/migrate/bundle";
+import store from "#db/migrate/store";
+import c from "@rcompat/cli/color";
+import print from "@rcompat/cli/print";
+import is_cancel from "@rcompat/cli/prompts/is-cancel";
+import text from "@rcompat/cli/prompts/text";
+import fs from "@rcompat/fs";
+import string from "@rcompat/string";
+function generate_migration(diffs) {
+    const lines = ["export default async db => {"];
+    for (const entry of diffs) {
+        if (entry.op === "create") {
+            const { store } = entry;
+            const types = Object.entries(store.types)
+                .map(([k, v]) => `    ${k}: "${v}"`)
+                .join(",\n");
+            const options = `{ name: "${store.pk}", generate: true }`;
+            lines.push(`  await db.schema.create("${store.name}", ${options}, {`);
+            lines.push(`${types}`);
+            lines.push("  });");
+        }
+        else {
+            const { store, diff } = entry;
+            lines.push(`  await db.schema.alter("${store.name}", {`);
+            lines.push(`    add: { ${Object.entries(diff.add).map(([k, v]) => `${k}: "${v}"`).join(", ")} },`);
+            lines.push(`    drop: [${diff.drop.map(f => `"${f}"`).join(", ")}],`);
+            lines.push(`    rename: [${diff.rename.map(([f, t]) => `["${f}", "${t}"]`).join(", ")}],`);
+            lines.push("  });");
+        }
+    }
+    lines.push("};");
+    return lines.join("\n");
+}
+export default async function create_migration(desc) {
+    const root = await fs.project.root();
+    const migrations = root.join("migrations");
+    // discover store files
+    const stores_dir = root.join("stores");
+    if (!await stores_dir.exists())
+        throw E.store_directory_missing();
+    const store_files = await stores_dir.files({
+        recursive: true,
+        filter: /\.[jt]s$/,
+    });
+    if (store_files.length === 0)
+        throw E.store_directory_empty();
+    let next = 1;
+    if (await migrations.exists()) {
+        const Migration = await store();
+        await Migration.table.create();
+        const last = await Migration.find({ limit: 1, sort: { id: "desc" } });
+        const last_id = last.length === 0 ? 0 : last[0].id;
+        const files = await migrations.files({ filter: /\d+-.*\.ts$/ });
+        const highest = files.length === 0 ? 0 : Math.max(...files.map(f => parseInt(f.name.split("-")[0])));
+        if (highest > last_id)
+            throw E.unapplied_migrations();
+        next = highest + 1;
+    }
+    // generate virtual entry
+    const entry = store_files.map((f, i) => `import s${i} from "${f.path}";`).join("\n") + `\nexport default [
+    ${store_files.map((_, i) => `s${i}`).join(",\n ")}\n];`;
+    const stores = await bundle(entry);
+    const diffs = [];
+    const migration_stores = stores.filter(s => s.migrate);
+    const names = new Map();
+    for (let i = 0; i < store_files.length; i++) {
+        const file = store_files[i];
+        const store = stores[i];
+        if (!store.migrate)
+            continue;
+        const existing = names.get(store.name) ?? [];
+        names.set(store.name, [...existing, file.name]);
+    }
+    const conflicts = [...names.entries()].filter(([, files]) => files.length > 1);
+    if (conflicts.length > 0) {
+        const messages = conflicts
+            .map(([name, files]) => `table "${name}" claimed by: ${files.join(", ")}`)
+            .join("\n");
+        throw E.migration_store_conflict(messages);
+    }
+    for (const store of migration_stores) {
+        const current = await store.db.schema.introspect(store.name, store.pk);
+        // table doesn't exist yet, create
+        if (current === null) {
+            diffs.push({
+                op: "create",
+                store,
+            });
+            continue;
+        }
+        const db_fields = new Set(Object.keys(current));
+        const store_fields = new Set(Object.keys(store.types));
+        const add = Object.fromEntries([...store_fields]
+            .filter(f => !db_fields.has(f))
+            .map(f => [f, store.types[f]]));
+        const drop = [...db_fields].filter(f => !store_fields.has(f));
+        if (Object.keys(add).length === 0 && drop.length === 0)
+            continue;
+        diffs.push({
+            store,
+            op: "alter",
+            diff: { add, drop, rename: [] },
+        });
+    }
+    for (const diff_entry of diffs) {
+        if (diff_entry.op !== "alter")
+            continue;
+        const { diff, store } = diff_entry;
+        const current = await store.db.schema.introspect(store.name, store.pk);
+        const confirmed_renames = [];
+        const confirmed_drops = [];
+        for (const dropped of diff.drop) {
+            const candidates = current[dropped] ?? [];
+            const matching_added = Object.entries(diff.add)
+                .filter(([, type]) => candidates.includes(type))
+                .map(([name]) => name);
+            if (matching_added.length === 0) {
+                confirmed_drops.push(dropped);
+                continue;
+            }
+            for (const added of matching_added) {
+                const d = c.bold(dropped);
+                const a = c.bold(added);
+                const answer = await text({
+                    message: `${d} was removed and ${a} was `
+                        + `added with a compatible type. Rename ${d} → ${a}? (y/N)`,
+                });
+                if (!is_cancel(answer) && answer.toLowerCase() === "y") {
+                    confirmed_renames.push([dropped, added]);
+                    delete diff.add[added];
+                }
+                else {
+                    confirmed_drops.push(dropped);
+                }
+            }
+        }
+        diff.rename = confirmed_renames;
+        diff.drop = confirmed_drops;
+    }
+    if (diffs.length === 0) {
+        print("No schema changes detected.\n");
+        return;
+    }
+    if (!await migrations.exists())
+        await migrations.create();
+    const content = generate_migration(diffs);
+    const filename = `${next}-${string.toSlug(desc)}.ts`;
+    await migrations.join(filename).write(content);
+    print(`Created ${c.bold(`migrations/${filename}`)}.\n`);
+    process.exit();
+}
+;
+//# sourceMappingURL=create.js.map

package/lib/private/db/migrate/index.d.ts

@@ -0,0 +1,10 @@
+import apply from "#db/migrate/apply";
+import create from "#db/migrate/create";
+import status from "#db/migrate/status";
+declare const migrate: {
+    apply: typeof apply;
+    create: typeof create;
+    status: typeof status;
+};
+export default migrate;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/db/migrate/index.js

@@ -0,0 +1,6 @@
+import apply from "#db/migrate/apply";
+import create from "#db/migrate/create";
+import status from "#db/migrate/status";
+const migrate = { apply, create, status };
+export default migrate;
+//# sourceMappingURL=index.js.map