@casekit/orm2-migrate 0.0.0-20250322230249

package/build/drop.d.ts

@@ -0,0 +1,2 @@
+import { Orm } from "@casekit/orm2";
+export declare const drop: (db: Orm) => Promise<void>;

package/build/drop.js

@@ -0,0 +1,12 @@
+import { sql } from "@casekit/orm2";
+export const drop = async (db) => {
+    const schemas = new Set(Object.values(db.config.models).map((model) => model.schema));
+    await db.transact(async (db) => {
+        for (const schema of schemas.values()) {
+            console.log(` - Dropping schema ${schema}`);
+            await db.query `
+                DROP SCHEMA IF EXISTS ${sql.ident(schema)} CASCADE;
+            `;
+        }
+    });
+};

package/build/index.d.ts

@@ -0,0 +1,19 @@
+export declare const migrate: {
+    drop: (db: import("@casekit/orm2").Orm) => Promise<void>;
+    push: (db: import("@casekit/orm2").Orm) => Promise<void>;
+    pull: (db: import("@casekit/orm2").Orm, schemas: string[]) => Promise<{
+        table: string;
+        schema: string;
+        column: string;
+        type: string;
+        nullable: boolean;
+        default: string | null;
+        ordinalPosition: number | null;
+        udtSchema: string;
+        udt: string;
+        elementType: string | null;
+        elementTypeSchema: string | null;
+        cardinality: number;
+        size: number | null;
+    }[]>;
+};

package/build/index.js

@@ -0,0 +1,8 @@
+import { drop } from "#drop.js";
+import { pull } from "#pull.js";
+import { push } from "#push.js";
+export const migrate = {
+    drop,
+    push,
+    pull,
+};

package/build/pull/getTables.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare const TableColumnSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodString;
+    column: z.ZodString;
+    ordinalPosition: z.ZodNullable<z.ZodNumber>;
+    type: z.ZodString;
+    default: z.ZodNullable<z.ZodString>;
+    nullable: z.ZodBoolean;
+    udtSchema: z.ZodString;
+    udt: z.ZodString;
+    elementType: z.ZodNullable<z.ZodString>;
+    elementTypeSchema: z.ZodNullable<z.ZodString>;
+    cardinality: z.ZodNumber;
+    size: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    table: string;
+    schema: string;
+    column: string;
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    ordinalPosition: number | null;
+    udtSchema: string;
+    udt: string;
+    elementType: string | null;
+    elementTypeSchema: string | null;
+    cardinality: number;
+    size: number | null;
+}, {
+    table: string;
+    schema: string;
+    column: string;
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    ordinalPosition: number | null;
+    udtSchema: string;
+    udt: string;
+    elementType: string | null;
+    elementTypeSchema: string | null;
+    cardinality: number;
+    size: number | null;
+}>;
+export type TableColumn = z.infer<typeof TableColumnSchema>;
+export declare const getTables: (schemas: string[]) => import("@casekit/orm2").SQLStatement<{
+    table: string;
+    schema: string;
+    column: string;
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    ordinalPosition: number | null;
+    udtSchema: string;
+    udt: string;
+    elementType: string | null;
+    elementTypeSchema: string | null;
+    cardinality: number;
+    size: number | null;
+}>;

package/build/pull/getTables.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { sql } from "@casekit/orm2";
+export const TableColumnSchema = z.object({
+    schema: z.string(),
+    table: z.string(),
+    column: z.string(),
+    ordinalPosition: z.number().nullable(),
+    type: z.string(),
+    default: z.string().nullable(),
+    nullable: z.boolean(),
+    udtSchema: z.string(),
+    udt: z.string(),
+    elementType: z.string().nullable(),
+    elementTypeSchema: z.string().nullable(),
+    cardinality: z.number(),
+    size: z.number().nullable(),
+});
+export const getTables = (schemas) => sql(TableColumnSchema) `
+        SELECT
+            c.table_schema AS "schema",
+            c.table_name AS "table",
+            c.column_name AS "column",
+            c.ordinal_position AS "ordinalPosition",
+            c.data_type AS "type",
+            c.column_default AS "default",
+            c.is_nullable = 'YES' AS "nullable",
+            c.udt_schema AS "udtSchema",
+            c.udt_name AS "udt",
+            e.data_type AS "elementType",
+            e.udt_schema AS "elementTypeSchema",
+            pa.attndims AS cardinality,
+            c.character_maximum_length AS "size"
+        FROM
+            information_schema.tables t
+            JOIN information_schema.columns c ON t.table_name = c.table_name
+                AND t.table_schema = c.table_schema
+                AND t.table_catalog = c.table_catalog
+            JOIN pg_catalog.pg_class pc ON pc.relname = c.table_name
+            JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace
+                AND pn.nspname = c.table_schema
+            JOIN pg_catalog.pg_attribute pa ON pa.attrelid = pc.oid
+                AND pa.attname = c.column_name
+            LEFT JOIN information_schema.element_types e ON c.table_catalog = e.object_catalog
+                AND c.table_schema = e.object_schema
+                AND c.table_name = e.object_name
+                AND e.object_type = 'TABLE'
+                AND e.collection_type_identifier = c.dtd_identifier
+                AND c.data_type = 'ARRAY'
+        WHERE
+            t.table_schema IN (${schemas})
+            AND t.table_type = 'BASE TABLE'
+            AND pa.attnum > 0
+        ORDER BY
+            t.table_name,
+            c.ordinal_position
+    `;

package/build/pull/getTables.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/pull/getTables.test.js

@@ -0,0 +1,298 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { orm, sql } from "@casekit/orm2";
+import { getTables } from "./getTables.js";
+describe("getTables", () => {
+    const db = orm({
+        schema: "migrate-get-tables-test",
+        models: {},
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    beforeEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-tables-test" CASCADE;`;
+        await db.query `CREATE SCHEMA IF NOT EXISTS "migrate-get-tables-test";`;
+    });
+    afterEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-tables-test" CASCADE;`;
+    });
+    test("with an empty database it returns no tables or columns", async () => {
+        const statement = getTables(["migrate-get-tables-test"]);
+        const result = await db.query(statement);
+        expect(result).toEqual([]);
+    });
+    test.for([
+        [
+            "handles uuid columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."uuid_test" (
+                    "uuid_col" UUID DEFAULT gen_random_uuid(),
+                    "uuid_col_notnull" UUID NOT NULL
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "uuid",
+                    default: "gen_random_uuid()",
+                    nullable: true,
+                }),
+                expect.objectContaining({
+                    type: "uuid",
+                    nullable: false,
+                }),
+            ],
+        ],
+        [
+            "handles serial columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."serial_test" (
+                    "smallserial_col" SMALLSERIAL,
+                    "serial_col" SERIAL,
+                    "bigserial_col" BIGSERIAL
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "smallint",
+                    default: expect.stringContaining("nextval"),
+                    nullable: false,
+                }),
+                expect.objectContaining({
+                    type: "integer",
+                    default: expect.stringContaining("nextval"),
+                    nullable: false,
+                }),
+                expect.objectContaining({
+                    type: "bigint",
+                    default: expect.stringContaining("nextval"),
+                    nullable: false,
+                }),
+            ],
+        ],
+        [
+            "handles boolean columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."boolean_test" (
+                    "bool_col" BOOLEAN DEFAULT true
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "boolean",
+                    default: "true",
+                }),
+            ],
+        ],
+        [
+            "handles numeric columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."numeric_test" (
+                    "numeric_col" NUMERIC(10,2)
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "numeric",
+                    udt: "numeric",
+                }),
+            ],
+        ],
+        [
+            "handles various numeric and decimal types",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."number_test" (
+                    "smallint_col" SMALLINT,
+                    "integer_col" INTEGER,
+                    "bigint_col" BIGINT,
+                    "decimal_col" DECIMAL(10,2),
+                    "real_col" REAL,
+                    "double_col" DOUBLE PRECISION
+                );
+            `,
+            [
+                expect.objectContaining({ type: "smallint", udt: "int2" }),
+                expect.objectContaining({ type: "integer", udt: "int4" }),
+                expect.objectContaining({ type: "bigint", udt: "int8" }),
+                expect.objectContaining({ type: "numeric", udt: "numeric" }),
+                expect.objectContaining({ type: "real", udt: "float4" }),
+                expect.objectContaining({
+                    type: "double precision",
+                    udt: "float8",
+                }),
+            ],
+        ],
+        [
+            "handles character types",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."char_test" (
+                    "char_col" CHAR(10),
+                    "varchar_col" VARCHAR(50),
+                    "text_col" TEXT,
+                    "name_col" NAME
+                );
+            `,
+            [
+                expect.objectContaining({ type: "character", size: 10 }),
+                expect.objectContaining({
+                    type: "character varying",
+                    size: 50,
+                }),
+                expect.objectContaining({ type: "text" }),
+                expect.objectContaining({ type: "name" }),
+            ],
+        ],
+        [
+            "handles date and time types",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."datetime_test" (
+                    "date_col" DATE,
+                    "time_col" TIME,
+                    "timetz_col" TIME WITH TIME ZONE,
+                    "timestamp_col" TIMESTAMP,
+                    "timestamptz_col" TIMESTAMP WITH TIME ZONE,
+                    "interval_col" INTERVAL
+                );
+            `,
+            [
+                expect.objectContaining({ type: "date" }),
+                expect.objectContaining({ type: "time without time zone" }),
+                expect.objectContaining({ type: "time with time zone" }),
+                expect.objectContaining({
+                    type: "timestamp without time zone",
+                }),
+                expect.objectContaining({ type: "timestamp with time zone" }),
+                expect.objectContaining({ type: "interval" }),
+            ],
+        ],
+        [
+            "handles array columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."array_test" (
+                    "array_col" INTEGER[]
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "ARRAY",
+                    elementType: "integer",
+                    cardinality: 1,
+                }),
+            ],
+        ],
+        [
+            "handles multi-dimensional array columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."array_test" (
+                    "multi_dim_array_col" TEXT[][][] NOT NULL DEFAULT ARRAY[ARRAY[ARRAY['a']]]
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "ARRAY",
+                    elementType: "text",
+                    cardinality: 3,
+                    nullable: false,
+                    default: "ARRAY[ARRAY[ARRAY['a'::text]]]",
+                }),
+            ],
+        ],
+        [
+            "handles json columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."json_test" (
+                    "json_col" JSON
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "json",
+                }),
+            ],
+        ],
+        [
+            "handles enum columns",
+            sql `
+                CREATE TYPE "migrate-get-tables-test"."mood" AS ENUM ('happy', 'sad');
+                CREATE TABLE "migrate-get-tables-test"."enum_test" (
+                    "enum_col" "migrate-get-tables-test"."mood"
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "USER-DEFINED",
+                    udtSchema: "migrate-get-tables-test",
+                    udt: "mood",
+                }),
+            ],
+        ],
+        [
+            "handles composite type columns",
+            sql `
+                CREATE TYPE "migrate-get-tables-test"."complex" AS (x double precision, y double precision);
+                CREATE TABLE "migrate-get-tables-test"."composite_test" (
+                    "complex_col" "migrate-get-tables-test"."complex"
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "USER-DEFINED",
+                    udtSchema: "migrate-get-tables-test",
+                    udt: "complex",
+                }),
+            ],
+        ],
+        [
+            "handles currency columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."currency_test" (
+                    "money_col" MONEY DEFAULT 42.42
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "money",
+                    default: "42.42",
+                }),
+            ],
+        ],
+        [
+            "handles geometric columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."geometry_test" (
+                    "point_col" POINT,
+                    "line_col" LINE,
+                    "polygon_col" POLYGON
+                );
+            `,
+            [
+                expect.objectContaining({ type: "point" }),
+                expect.objectContaining({ type: "line" }),
+                expect.objectContaining({ type: "polygon" }),
+            ],
+        ],
+        [
+            "handles network address columns",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."network_test" (
+                    "inet_col" INET,
+                    "cidr_col" CIDR,
+                    "macaddr_col" MACADDR
+                );
+            `,
+            [
+                expect.objectContaining({ type: "inet" }),
+                expect.objectContaining({ type: "cidr" }),
+                expect.objectContaining({ type: "macaddr" }),
+            ],
+        ],
+    ])("%s", async ([_, query, expected]) => {
+        await db.transact(async (db) => {
+            await db.query(query);
+            const result = await db.query(getTables(["migrate-get-tables-test"]));
+            expect(result).toEqual(expected);
+        }, { rollback: true });
+    });
+});

package/build/pull.d.ts

@@ -0,0 +1,16 @@
+import { Orm } from "@casekit/orm2";
+export declare const pull: (db: Orm, schemas: string[]) => Promise<{
+    table: string;
+    schema: string;
+    column: string;
+    type: string;
+    nullable: boolean;
+    default: string | null;
+    ordinalPosition: number | null;
+    udtSchema: string;
+    udt: string;
+    elementType: string | null;
+    elementTypeSchema: string | null;
+    cardinality: number;
+    size: number | null;
+}[]>;

package/build/pull.js

@@ -0,0 +1,4 @@
+import { getTables } from "./pull/getTables.js";
+export const pull = async (db, schemas) => {
+    return await db.query(getTables(schemas));
+};

package/build/push/arrayToSqlArray.d.ts

@@ -0,0 +1 @@
+export declare const arrayToSqlArray: (values: unknown[]) => string;

package/build/push/arrayToSqlArray.js

@@ -0,0 +1,6 @@
+export const arrayToSqlArray = (values) => {
+    const joined = values
+        .map((v) => (Array.isArray(v) ? arrayToSqlArray(v) : JSON.stringify(v)))
+        .join(", ");
+    return `{ ${joined} }`;
+};

package/build/push/arrayToSqlArray.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/push/arrayToSqlArray.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "vitest";
+import { arrayToSqlArray } from "./arrayToSqlArray.js";
+describe("arrayToSqlArray", () => {
+    test("converts a flat array to SQL array format", () => {
+        const input = [1, 2, 3];
+        const output = arrayToSqlArray(input);
+        expect(output).toBe("{ 1, 2, 3 }");
+    });
+    test("converts a nested array to SQL array format", () => {
+        const input = [1, [2, 3], 4];
+        const output = arrayToSqlArray(input);
+        expect(output).toBe("{ 1, { 2, 3 }, 4 }");
+    });
+    test("converts an array with strings to SQL array format", () => {
+        const input = ["a", "b", "c"];
+        const output = arrayToSqlArray(input);
+        expect(output).toBe('{ "a", "b", "c" }');
+    });
+    test("converts a mixed array to SQL array format", () => {
+        const input = [1, "b", [2, "c"]];
+        const output = arrayToSqlArray(input);
+        expect(output).toBe('{ 1, "b", { 2, "c" } }');
+    });
+    test("converts an empty array to SQL array format", () => {
+        const input = [];
+        const output = arrayToSqlArray(input);
+        expect(output).toBe("{  }");
+    });
+});

package/build/push/createExtensionSql.d.ts

@@ -0,0 +1,2 @@
+import { SQLStatement } from "@casekit/orm2";
+export declare const createExtensionsSql: (extension: string) => SQLStatement;

package/build/push/createExtensionSql.js

@@ -0,0 +1,4 @@
+import { sql } from "@casekit/orm2";
+export const createExtensionsSql = (extension) => {
+    return sql `CREATE EXTENSION IF NOT EXISTS ${sql.ident(extension)};`;
+};

package/build/push/createExtensionSql.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/push/createExtensionSql.test.js

@@ -0,0 +1,20 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm } from "@casekit/orm2";
+import { createExtensionsSql } from "./createExtensionSql.js";
+describe("createExtensionsSql", () => {
+    const db = orm({ models: {} });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test("creates SQL statement for creating an extension", async () => {
+        const statement = createExtensionsSql("uuid-ossp");
+        expect(statement.text).toEqual('CREATE EXTENSION IF NOT EXISTS "uuid-ossp";');
+        expect(statement.values).toEqual([]);
+        await db.transact(async (db) => {
+            await expect(db.query(statement)).resolves.not.toThrow();
+        }, { rollback: true });
+    });
+});

package/build/push/createForeignKeyConstraintSql.d.ts

@@ -0,0 +1,3 @@
+import { SQLStatement } from "@casekit/orm2";
+import { NormalizedForeignKeyDefinition, NormalizedModelDefinition } from "@casekit/orm2-config";
+export declare const createForeignKeyConstraintSql: (model: NormalizedModelDefinition, fk: NormalizedForeignKeyDefinition) => SQLStatement<import("pg").QueryResultRow>;

package/build/push/createForeignKeyConstraintSql.js

@@ -0,0 +1,17 @@
+import { SQLStatement, sql } from "@casekit/orm2";
+export const createForeignKeyConstraintSql = (model, fk) => {
+    const statement = sql `
+        ALTER TABLE ${sql.ident(model.schema)}.${sql.ident(model.table)}
+        ADD CONSTRAINT ${sql.ident(fk.name)}
+        FOREIGN KEY (${sql.join(fk.columns.map(sql.ident), ", ")})
+        REFERENCES ${sql.ident(fk.references.schema)}.${sql.ident(fk.references.table)} (${sql.join(fk.references.columns.map(sql.ident), ", ")})`;
+    if (fk.onDelete) {
+        statement.append `
+        ON DELETE ${new SQLStatement(fk.onDelete)}`;
+    }
+    if (fk.onUpdate) {
+        statement.append `
+        ON UPDATE ${new SQLStatement(fk.onUpdate)}`;
+    }
+    return statement;
+};

package/build/push/createForeignKeyConstraintSql.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/push/createForeignKeyConstraintSql.test.js

@@ -0,0 +1,142 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm } from "@casekit/orm2";
+import { unindent } from "@casekit/unindent";
+import { createForeignKeyConstraintSql } from "./createForeignKeyConstraintSql.js";
+describe("createForeignKeyConstraintSql", () => {
+    const db = orm({
+        schema: "orm",
+        models: {
+            foo: {
+                table: "foo",
+                fields: {
+                    id: { type: "serial", primaryKey: true },
+                    barId: { column: "bar_id", type: "integer" },
+                    otherFooId: { column: "other_foo_id", type: "integer" },
+                },
+            },
+            bar: {
+                table: "bar",
+                fields: {
+                    id: { type: "serial", primaryKey: true },
+                    fooId: { column: "foo_id", type: "integer" },
+                },
+            },
+            baz: {
+                table: "baz",
+                fields: {
+                    id: { type: "serial", primaryKey: true },
+                    fooId: { column: "foo_id", type: "integer" },
+                    barId: { column: "bar_id", type: "integer" },
+                },
+            },
+        },
+    });
+    const foo = db.config.models["foo"];
+    const baz = db.config.models["baz"];
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test.for([
+        [
+            "basic foreign key",
+            foo,
+            {
+                name: "foo_other_foo_id_fk",
+                fields: ["otherFooId"],
+                columns: ["other_foo_id"],
+                references: {
+                    model: "foo",
+                    schema: "orm",
+                    table: "foo",
+                    fields: ["id"],
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: null,
+            },
+            unindent `
+                ALTER TABLE "orm"."foo"
+                ADD CONSTRAINT "foo_other_foo_id_fk" FOREIGN KEY ("other_foo_id") REFERENCES "orm"."foo" ("id")
+            `,
+        ],
+        [
+            "on update cascade",
+            foo,
+            {
+                name: "foo_other_foo_id_fk",
+                fields: ["otherFooId"],
+                columns: ["other_foo_id"],
+                references: {
+                    model: "foo",
+                    schema: "orm",
+                    table: "foo",
+                    fields: ["id"],
+                    columns: ["id"],
+                },
+                onUpdate: "CASCADE",
+                onDelete: null,
+            },
+            unindent `
+                ALTER TABLE "orm"."foo"
+                ADD CONSTRAINT "foo_other_foo_id_fk" FOREIGN KEY ("other_foo_id") REFERENCES "orm"."foo" ("id") ON UPDATE CASCADE
+            `,
+        ],
+        [
+            "on delete set null",
+            foo,
+            {
+                name: "foo_other_foo_id_fk",
+                fields: ["otherFooId"],
+                columns: ["other_foo_id"],
+                references: {
+                    model: "foo",
+                    schema: "orm",
+                    table: "foo",
+                    fields: ["id"],
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: "SET NULL",
+            },
+            unindent `
+                ALTER TABLE "orm"."foo"
+                ADD CONSTRAINT "foo_other_foo_id_fk" FOREIGN KEY ("other_foo_id") REFERENCES "orm"."foo" ("id") ON DELETE SET NULL
+            `,
+        ],
+        [
+            "multi-column",
+            baz,
+            {
+                name: "baz_foo_id_bar_id_fk",
+                fields: ["fooId", "barId"],
+                columns: ["foo_id", "bar_id"],
+                references: {
+                    model: "foo",
+                    schema: "orm",
+                    table: "foo",
+                    fields: ["otherFooId", "barId"],
+                    columns: ["other_foo_id", "bar_id"],
+                },
+                onUpdate: "RESTRICT",
+                onDelete: "SET NULL",
+            },
+            unindent `
+                ALTER TABLE "orm"."baz"
+                ADD CONSTRAINT "baz_foo_id_bar_id_fk" FOREIGN KEY ("foo_id", "bar_id") REFERENCES "orm"."foo" ("other_foo_id", "bar_id") ON DELETE SET NULL ON UPDATE RESTRICT
+            `,
+        ],
+    ])("%s", async ([_, model, fk, expected]) => {
+        const statement = createForeignKeyConstraintSql(model, fk);
+        expect(statement.pretty).toEqual(expected);
+        await db.transact(async (db) => {
+            await db.query `CREATE TABLE orm.foo (id SERIAL PRIMARY KEY, bar_id INTEGER, other_foo_id INTEGER)`;
+            await db.query `CREATE TABLE orm.bar (id SERIAL PRIMARY KEY, foo_id INTEGER)`;
+            await db.query `CREATE TABLE orm.baz (id SERIAL PRIMARY KEY, foo_id INTEGER, bar_id INTEGER)`;
+            await db.query `CREATE UNIQUE INDEX foo_other_foo_id_bar_id_key ON orm.foo (other_foo_id, bar_id)`;
+            await expect(db.query(statement)).resolves.not.toThrow();
+        }, { rollback: true });
+    });
+});

package/build/push/createSchemaSql.d.ts

@@ -0,0 +1 @@
+export declare const createSchemaSql: (schema: string) => import("@casekit/sql").SQLStatement<import("pg").QueryResultRow>;

package/build/push/createSchemaSql.js

@@ -0,0 +1,7 @@
+import { sql } from "@casekit/sql";
+export const createSchemaSql = (schema) => {
+    if (schema === "") {
+        throw new Error("Cannot create schema with empty name");
+    }
+    return sql `CREATE SCHEMA IF NOT EXISTS ${sql.ident(schema)};`;
+};

package/build/push/createSchemaSql.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/push/createSchemaSql.test.js

@@ -0,0 +1,26 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm } from "@casekit/orm2";
+import { createSchemaSql } from "./createSchemaSql.js";
+describe("createSchemaSql", () => {
+    const db = orm({ models: {} });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test.for([
+        ["basic schema name", "test_schema"],
+        ["schema name with spaces", "test schema"],
+        ["malicious", "test-schema;drop table"],
+    ])("%s", async ([, schema]) => {
+        const result = createSchemaSql(schema);
+        expect(result.text).toBe(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
+        await db.transact(async (db) => {
+            await expect(db.query(result)).resolves.not.toThrow();
+        }, { rollback: true });
+    });
+    test("should throw on empty schema name", () => {
+        expect(() => createSchemaSql("")).toThrowError("Cannot create schema with empty name");
+    });
+});

package/build/push/createTableSql.d.ts

@@ -0,0 +1,3 @@
+import { SQLStatement } from "@casekit/orm2";
+import { NormalizedModelDefinition } from "@casekit/orm2-config";
+export declare const createTableSql: (model: NormalizedModelDefinition) => SQLStatement;

package/build/push/createTableSql.js

@@ -0,0 +1,37 @@
+import { SQLStatement, sql } from "@casekit/orm2";
+import { arrayToSqlArray } from "#push/arrayToSqlArray.js";
+export const createTableSql = (model) => {
+    const fields = Object.values(model.fields);
+    const primaryKey = model.primaryKey;
+    const statement = sql `CREATE TABLE IF NOT EXISTS ${sql.ident(model.schema)}.${sql.ident(model.table)} (\n`;
+    for (const field of fields) {
+        statement.append `  ${sql.ident(field.column)} `;
+        // dangerously appending raw SQL here, but we need to,
+        // and this only comes from user-defined schemas, so should be ok
+        statement.push(new SQLStatement(field.type));
+        if (!field.nullable)
+            statement.append ` NOT NULL`;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- let's do this check to be safe
+        if (field.default !== null || field.default === undefined) {
+            statement.append ` DEFAULT `;
+            if (field.default instanceof SQLStatement) {
+                statement.push(field.default);
+            }
+            else if (typeof field.default === "string") {
+                statement.push(sql.literal(field.default));
+            }
+            else if (Array.isArray(field.default)) {
+                statement.push(sql.literal(arrayToSqlArray(field.default)));
+            }
+            else {
+                statement.push(sql.literal(JSON.stringify(field.default)));
+            }
+        }
+        statement.append `,\n`;
+    }
+    if (primaryKey.length > 0) {
+        statement.append `  PRIMARY KEY (${sql.join(primaryKey.map((pk) => sql.ident(pk.column)), ", ")})`;
+    }
+    statement.append `\n);`;
+    return statement;
+};

package/build/push/createTableSql.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/push/createTableSql.test.js

@@ -0,0 +1,99 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm, sql } from "@casekit/orm2";
+import { normalizeConfig } from "@casekit/orm2-config";
+import { config } from "@casekit/orm2-fixtures";
+import { unindent } from "@casekit/unindent";
+import { createTableSql } from "./createTableSql.js";
+describe("createTableSql", () => {
+    const db = orm(config);
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test.for([
+        [
+            "integer",
+            {},
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" integer NOT NULL,
+                    PRIMARY KEY ("id")
+                );
+            `,
+        ],
+        [
+            "text",
+            { nullable: true },
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" text,
+                    PRIMARY KEY ("id")
+                );
+            `,
+        ],
+        [
+            "integer",
+            { unique: true, default: 1312 },
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" integer NOT NULL DEFAULT '1312',
+                    PRIMARY KEY ("id")
+                );
+            `,
+        ],
+        [
+            "text",
+            { unique: true, default: "foo" },
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" text NOT NULL DEFAULT 'foo',
+                    PRIMARY KEY ("id")
+                );
+            `,
+        ],
+        [
+            "uuid",
+            { default: sql `uuid_generate_v4()` },
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" uuid NOT NULL DEFAULT uuid_generate_v4 (),
+                    PRIMARY KEY ("id")
+                );
+            `,
+        ],
+        [
+            "text[][][]",
+            { default: [[[1, 2, 3]]] },
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" text[] [] [] NOT NULL DEFAULT '{ { { 1, 2, 3 } } }',
+                    PRIMARY KEY ("id")
+                );
+            `,
+        ],
+    ])("%s %s", async ([type, options, expected]) => {
+        const config = normalizeConfig({
+            models: {
+                foo: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        value: { type: type, ...options },
+                    },
+                },
+            },
+        });
+        const statement = createTableSql(config.models["foo"]);
+        expect(statement.pretty).toEqual(expected);
+        await db.transact(async (db) => {
+            await expect(db.query(statement)).resolves.not.toThrow();
+        }, { rollback: true });
+    });
+});

package/build/push/createUniqueConstraintSql.d.ts

@@ -0,0 +1,2 @@
+import { NormalizedModelDefinition, NormalizedUniqueConstraintDefinition } from "@casekit/orm2-config";
+export declare const createUniqueConstraintSql: (model: NormalizedModelDefinition, constraint: NormalizedUniqueConstraintDefinition) => import("@casekit/orm2").SQLStatement<import("pg").QueryResultRow>;

package/build/push/createUniqueConstraintSql.js

@@ -0,0 +1,17 @@
+import { sql } from "@casekit/orm2";
+export const createUniqueConstraintSql = (model, constraint) => {
+    const statement = sql `
+        CREATE UNIQUE INDEX ${sql.ident(constraint.name)}
+        ON ${sql.ident(model.schema)}.${sql.ident(model.table)}
+        (${sql.join(constraint.columns.map(sql.ident), ", ")})
+`;
+    if (constraint.nullsNotDistinct) {
+        statement.append `
+        NULLS NOT DISTINCT`;
+    }
+    if (constraint.where) {
+        statement.append `
+        WHERE ${constraint.where}`;
+    }
+    return statement;
+};

package/build/push/createUniqueConstraintSql.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/push/createUniqueConstraintSql.test.js

@@ -0,0 +1,105 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm, sql } from "@casekit/orm2";
+import { unindent } from "@casekit/unindent";
+import { createUniqueConstraintSql } from "./createUniqueConstraintSql.js";
+describe("createUniqueConstraintSql", () => {
+    const db = orm({
+        schema: "orm",
+        models: {
+            foo: {
+                table: "foo",
+                fields: {
+                    id: { type: "serial", primaryKey: true },
+                    fooValue: { column: "foo_value", type: "text" },
+                    barValue: { column: "bar_value", type: "integer" },
+                },
+            },
+        },
+    });
+    const foo = db.config.models["foo"];
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    test.for([
+        [
+            "basic unique constraint",
+            {
+                name: "foo_foo_value_key",
+                fields: ["fooValue"],
+                columns: ["foo_value"],
+                nullsNotDistinct: false,
+                where: null,
+            },
+            unindent `
+                CREATE UNIQUE INDEX "foo_foo_value_key" ON "orm"."foo" ("foo_value")
+            `,
+        ],
+        [
+            "nulls not distinct",
+            {
+                name: "foo_foo_value_key",
+                fields: ["fooValue"],
+                columns: ["foo_value"],
+                nullsNotDistinct: true,
+                where: null,
+            },
+            unindent `
+                CREATE UNIQUE INDEX "foo_foo_value_key" ON "orm"."foo" ("foo_value") NULLS NOT DISTINCT
+            `,
+        ],
+        [
+            "where clause",
+            {
+                name: "foo_foo_value_key",
+                fields: ["fooValue"],
+                columns: ["foo_value"],
+                nullsNotDistinct: false,
+                where: sql `bar_value > 0`,
+            },
+            unindent `
+                CREATE UNIQUE INDEX "foo_foo_value_key" ON "orm"."foo" ("foo_value")
+                WHERE
+                    bar_value > 0
+            `,
+        ],
+        [
+            "multi-column",
+            {
+                name: "foo_foo_value_bar_value_key",
+                fields: ["fooValue", "barValue"],
+                columns: ["foo_value", "bar_value"],
+                nullsNotDistinct: false,
+                where: null,
+            },
+            unindent `
+                CREATE UNIQUE INDEX "foo_foo_value_bar_value_key" ON "orm"."foo" ("foo_value", "bar_value")
+            `,
+        ],
+        [
+            "multi-column with nulls not distinct and where",
+            {
+                name: "foo_foo_value_bar_value_key",
+                fields: ["fooValue", "barValue"],
+                columns: ["foo_value", "bar_value"],
+                nullsNotDistinct: true,
+                where: sql `bar_value > 0 AND foo_value IS NOT NULL`,
+            },
+            unindent `
+                CREATE UNIQUE INDEX "foo_foo_value_bar_value_key" ON "orm"."foo" ("foo_value", "bar_value") NULLS NOT DISTINCT
+                WHERE
+                    bar_value > 0
+                    AND foo_value IS NOT NULL
+            `,
+        ],
+    ])("%s", async ([_, constraint, expected]) => {
+        const statement = createUniqueConstraintSql(foo, constraint);
+        expect(statement.pretty).toEqual(expected);
+        await db.transact(async (db) => {
+            await db.query `CREATE TABLE orm.foo (id SERIAL PRIMARY KEY, foo_value TEXT, bar_value INTEGER)`;
+            await expect(db.query(statement)).resolves.not.toThrow();
+        }, { rollback: true });
+    });
+});

package/build/push.d.ts

@@ -0,0 +1,2 @@
+import { Orm } from "@casekit/orm2";
+export declare const push: (db: Orm) => Promise<void>;

package/build/push.js

@@ -0,0 +1,36 @@
+import { toSentence } from "@casekit/toolbox";
+import { createExtensionsSql } from "#push/createExtensionSql.js";
+import { createForeignKeyConstraintSql } from "#push/createForeignKeyConstraintSql.js";
+import { createSchemaSql } from "#push/createSchemaSql.js";
+import { createTableSql } from "#push/createTableSql.js";
+import { createUniqueConstraintSql } from "#push/createUniqueConstraintSql.js";
+export const push = async (db) => {
+    const schemas = new Set(Object.values(db.config.models).map((model) => model.schema));
+    console.log(`Pushing schemas ${toSentence(schemas)} to database`);
+    await db.transact(async (db) => {
+        for (const extension of db.config.extensions) {
+            console.log(` - Creating extension "${extension}"`);
+            await db.query(createExtensionsSql(extension));
+        }
+        for (const schema of schemas.values()) {
+            console.log(` - Creating schema "${schema}"`);
+            await db.query(createSchemaSql(schema));
+        }
+        for (const model of Object.values(db.config.models)) {
+            console.log(` - Creating table "${model.schema}"."${model.table}"`);
+            await db.query(createTableSql(model));
+        }
+        for (const model of Object.values(db.config.models)) {
+            for (const fk of model.foreignKeys) {
+                console.log(` - Creating foreign key constraint "${fk.name}" ON "${model.table}"`);
+                await db.query(createForeignKeyConstraintSql(model, fk));
+            }
+        }
+        for (const model of Object.values(db.config.models)) {
+            for (const constraint of model.uniqueConstraints) {
+                console.log(` - Creating unique constraint "${constraint.name}" ON "${model.schema}"."${model.table}"`);
+                await db.query(createUniqueConstraintSql(model, constraint));
+            }
+        }
+    });
+};

package/build/render/renderDefault.d.ts

@@ -0,0 +1,2 @@
+export declare const isNumeric: (value: string) => boolean;
+export declare const renderDefault: (d: string) => string;

package/build/render/renderDefault.js

@@ -0,0 +1,12 @@
+export const isNumeric = (value) => {
+    return /^-?\d+(\.\d+)?$/.test(value);
+};
+export const renderDefault = (d) => {
+    return /^-?\d+$/.exec(d)
+        ? d
+        : /::text$/.exec(d)
+            ? d.replace(/::text$/, "")
+            : ["true", "false"].includes(d)
+                ? d
+                : `sql\`${d}\``;
+};

package/build/render/renderDefault.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/render/renderDefault.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "vitest";
+import { renderDefault } from "./renderDefault.js";
+describe("renderDefault", () => {
+    test("should return numeric values as-is", () => {
+        expect(renderDefault("42")).toBe("42");
+        expect(renderDefault("0")).toBe("0");
+        expect(renderDefault("-123")).toBe("-123");
+    });
+    test("should remove ::text suffix from text values", () => {
+        expect(renderDefault("hello::text")).toBe("hello");
+        expect(renderDefault("some string::text")).toBe("some string");
+    });
+    test("should return boolean literals as-is", () => {
+        expect(renderDefault("true")).toBe("true");
+        expect(renderDefault("false")).toBe("false");
+    });
+    test("should wrap other values in sql tag", () => {
+        expect(renderDefault("CURRENT_TIMESTAMP")).toBe("sql`CURRENT_TIMESTAMP`");
+        expect(renderDefault("uuid_generate_v4()")).toBe("sql`uuid_generate_v4()`");
+        expect(renderDefault("now()")).toBe("sql`now()`");
+        expect(renderDefault("hello")).toBe("sql`hello`");
+    });
+});

package/build/render/renderModel.d.ts

@@ -0,0 +1,2 @@
+import { TableColumn } from "#pull/getTables.js";
+export declare const generateModel: (columns: TableColumn[]) => string;

package/build/render/renderModel.js

@@ -0,0 +1,35 @@
+import camelcase from "camelcase";
+import { unindent } from "@casekit/unindent";
+// const renderType = (column: TableColumn) => {
+//     if (column.type === "ARRAY") {
+//         return (
+//             column.elementType +
+//             times(column.)
+//                 .map(() => "[]")
+//                 .join("")
+//         );
+//     } else {
+//         return column.type;
+//     }
+// };
+export const generateModel = (columns) => {
+    return unindent `
+        import { ModelDefinition } from "@casekit/orm2";
+
+        export const ${camelcase(columns[0].table)} = {
+            table: "${columns[0].table}",
+            fields: {
+                ${columns
+        .map((column) => {
+        return `${camelcase(column.column)}: {
+                        name: "${column.column}",
+                        type: "${column.type}",
+                        ${column.nullable ? "nullable: true," : ""}
+                        ${column.default ? `default: "${column.default}",` : ""}
+                    }`;
+    })
+        .join(",\n")}
+            },
+        } as const satisfies ModelDefinition;
+    `;
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@casekit/orm2-migrate",
+  "description": "",
+  "version": "0.0.0-20250322230249",
+  "author": "",
+  "dependencies": {
+    "camelcase": "^8.0.0",
+    "@casekit/orm2": "0.0.0-20250322230249",
+    "@casekit/orm2-schema": "0.0.0-20250322230249",
+    "@casekit/toolbox": "0.0.0-20250322230249",
+    "@casekit/orm2-config": "0.0.0-20250322230249",
+    "@casekit/sql": "0.0.0-20250322230249"
+  },
+  "devDependencies": {
+    "@casekit/unindent": "^1.0.5",
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^22.13.11",
+    "@types/pg": "^8.11.11",
+    "@types/uuid": "^10.0.0",
+    "@vitest/coverage-v8": "^3.0.9",
+    "dotenv": "^16.4.7",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.3.3",
+    "typescript": "^5.8.2",
+    "uuid": "^11.1.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.9",
+    "@casekit/orm2-fixtures": "0.0.0-20250322230249",
+    "@casekit/tsconfig": "0.0.0-20250322230249",
+    "@casekit/prettier-config": "0.0.0-20250322230249"
+  },
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "main": "index.js",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^3.24.2"
+  },
+  "prettier": "@casekit/prettier-config",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf ./build && tsc",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint src --max-warnings 0",
+    "test": "vitest --run --typecheck --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}