@casekit/orm-migrate 0.0.1-release-candidate

package/build/push/createForeignKeyConstraintSql.test.js

@@ -0,0 +1,142 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm } from "@casekit/orm";
+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/orm";
+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/orm";
+import { NormalizedModelDefinition } from "@casekit/orm-config";
+export declare const createTableSql: (model: NormalizedModelDefinition) => SQLStatement;

package/build/push/createTableSql.js

@@ -0,0 +1,38 @@
+import { SQLStatement, sql } from "@casekit/orm";
+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`;
+    fields.forEach((field, i) => {
+        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)));
+            }
+        }
+        if (i < fields.length - 1)
+            statement.append `,\n`;
+    });
+    if (primaryKey.length > 0) {
+        statement.append `,\n  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,110 @@
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { orm, sql } from "@casekit/orm";
+import { normalizeConfig } from "@casekit/orm-config";
+import { config } from "@casekit/orm-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")
+                );
+            `,
+        ],
+        [
+            "timestamp without time zone",
+            { default: sql `now()` },
+            unindent `
+                CREATE TABLE IF NOT EXISTS "public"."foo" (
+                    "id" serial NOT NULL,
+                    "value" timestamp without time zone NOT NULL DEFAULT now(),
+                    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/orm-config";
+export declare const createUniqueConstraintSql: (model: NormalizedModelDefinition, constraint: NormalizedUniqueConstraintDefinition) => import("@casekit/orm").SQLStatement<import("pg").QueryResultRow>;

package/build/push/createUniqueConstraintSql.js

@@ -0,0 +1,17 @@
+import { sql } from "@casekit/orm";
+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/orm";
+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/orm";
+export declare const push: (db: Orm) => Promise<void>;

package/build/push.js

@@ -0,0 +1,38 @@
+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 schema of schemas.values()) {
+            console.log(` - Creating schema "${schema}"`);
+            await db.query(createSchemaSql(schema));
+        }
+        for (const extension of db.config.extensions) {
+            console.log(` - Creating extension "${extension}"`);
+            for (const schema of schemas) {
+                await db.query(createExtensionsSql(schema, extension));
+            }
+        }
+        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/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@casekit/orm-migrate",
+  "description": "",
+  "version": "0.0.1-release-candidate",
+  "author": "",
+  "dependencies": {
+    "camelcase": "^8.0.0",
+    "es-toolkit": "^1.39.3",
+    "@casekit/orm": "0.0.1-release-candidate",
+    "@casekit/sql": "0.0.1-release-candidate",
+    "@casekit/orm-schema": "0.0.1-release-candidate",
+    "@casekit/toolbox": "0.0.1-release-candidate",
+    "@casekit/orm-config": "0.0.1-release-candidate"
+  },
+  "devDependencies": {
+    "@casekit/unindent": "^1.0.5",
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^24.0.3",
+    "@types/pg": "^8.15.4",
+    "@types/uuid": "^10.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^16.5.0",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.4.0",
+    "typescript": "^5.8.3",
+    "uuid": "^11.1.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4",
+    "@casekit/tsconfig": "0.0.1-release-candidate",
+    "@casekit/orm-fixtures": "0.0.1-release-candidate",
+    "@casekit/prettier-config": "0.0.1-release-candidate"
+  },
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^4.0.17"
+  },
+  "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"
+  }
+}