@casekit/orm-migrate 0.0.1-release-candidate

package/build/pull/getPrimaryKeys.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { sql } from "@casekit/orm";
+export const PrimaryKeySchema = z.object({
+    schema: z.string(),
+    table: z.string(),
+    constraintName: z.string(),
+    columns: z.array(z.string()),
+});
+export const getPrimaryKeys = (schemas) => sql(PrimaryKeySchema) `
+        SELECT
+            c.constraint_schema AS "schema",
+            c.table_name AS "table",
+            c.constraint_name AS "constraintName",
+            array_agg(cc.column_name::text ORDER BY cc.ordinal_position) AS "columns"
+        FROM
+            information_schema.table_constraints c
+            JOIN information_schema.key_column_usage cc ON c.constraint_name = cc.constraint_name
+                AND c.constraint_schema = cc.constraint_schema
+                AND c.table_name = cc.table_name
+        WHERE
+            c.constraint_type = 'PRIMARY KEY'
+            AND c.constraint_schema IN (${schemas})
+        GROUP BY
+            c.constraint_schema,
+            c.table_name,
+            c.constraint_name
+        ORDER BY
+            c.constraint_schema,
+            c.table_name
+    `;

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

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

package/build/pull/getPrimaryKeys.test.js

@@ -0,0 +1,87 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { orm, sql } from "@casekit/orm";
+import { getPrimaryKeys } from "./getPrimaryKeys.js";
+describe("getPrimaryKeys", () => {
+    const db = orm({
+        schema: "migrate-get-primary-keys-test",
+        models: {},
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    beforeEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-primary-keys-test" CASCADE;`;
+        await db.query `CREATE SCHEMA IF NOT EXISTS "migrate-get-primary-keys-test";`;
+    });
+    afterEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-primary-keys-test" CASCADE;`;
+    });
+    test("with an empty database it returns no primary keys", async () => {
+        const statement = getPrimaryKeys(["migrate-get-primary-keys-test"]);
+        const result = await db.query(statement);
+        expect(result).toEqual([]);
+    });
+    test("returns single column primary key", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-primary-keys-test"."users" (
+                        "id" SERIAL PRIMARY KEY,
+                        "name" TEXT NOT NULL
+                    );
+                `);
+            const result = await db.query(getPrimaryKeys(["migrate-get-primary-keys-test"]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-primary-keys-test",
+                    table: "users",
+                    constraintName: "users_pkey",
+                    columns: ["id"],
+                }),
+            ]);
+        }, { rollback: true });
+    });
+    test("returns composite primary key with correct order", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-primary-keys-test"."user_roles" (
+                        "user_id" INTEGER NOT NULL,
+                        "role_id" INTEGER NOT NULL,
+                        "granted_at" TIMESTAMP DEFAULT NOW(),
+                        PRIMARY KEY ("user_id", "role_id")
+                    );
+                `);
+            const result = await db.query(getPrimaryKeys(["migrate-get-primary-keys-test"]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-primary-keys-test",
+                    table: "user_roles",
+                    constraintName: "user_roles_pkey",
+                    columns: ["user_id", "role_id"],
+                }),
+            ]);
+        }, { rollback: true });
+    });
+    test("returns named primary key constraint", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-primary-keys-test"."products" (
+                        "id" UUID NOT NULL,
+                        "name" TEXT NOT NULL,
+                        CONSTRAINT "pk_products_id" PRIMARY KEY ("id")
+                    );
+                `);
+            const result = await db.query(getPrimaryKeys(["migrate-get-primary-keys-test"]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-primary-keys-test",
+                    table: "products",
+                    constraintName: "pk_products_id",
+                    columns: ["id"],
+                }),
+            ]);
+        }, { rollback: true });
+    });
+});

package/build/pull/getUniqueConstraints.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const UniqueConstraintSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodString;
+    name: z.ZodString;
+    definition: z.ZodString;
+}, z.core.$strip>;
+export type UniqueConstraint = z.infer<typeof UniqueConstraintSchema>;
+export declare const getUniqueConstraints: (schemas: string[]) => import("@casekit/orm").SQLStatement<{
+    schema: string;
+    table: string;
+    name: string;
+    definition: string;
+}>;

package/build/pull/getUniqueConstraints.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { sql } from "@casekit/orm";
+export const UniqueConstraintSchema = z.object({
+    schema: z.string(),
+    table: z.string(),
+    name: z.string(),
+    definition: z.string(),
+});
+export const getUniqueConstraints = (schemas) => sql(UniqueConstraintSchema) `
+        SELECT
+            i.schemaname AS "schema",
+            i.tablename AS "table",
+            i.indexname AS "name",
+            i.indexdef AS "definition"
+        FROM
+            pg_indexes i
+            LEFT JOIN pg_constraint c ON i.indexname = c.conname
+                AND c.contype IN ('p', 'x')
+        WHERE
+            i.schemaname IN (${schemas})
+            AND c.conname IS NULL
+            AND i.indexdef LIKE 'CREATE UNIQUE INDEX%'
+        ORDER BY
+            i.schemaname,
+            i.tablename,
+            i.indexname
+    `;

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

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

package/build/pull/getUniqueConstraints.test.js

@@ -0,0 +1,99 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { orm, sql } from "@casekit/orm";
+import { getUniqueConstraints } from "./getUniqueConstraints.js";
+describe("getUniqueConstraints", () => {
+    const db = orm({
+        schema: "migrate-get-unique-constraints-test",
+        models: {},
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    beforeEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-unique-constraints-test" CASCADE;`;
+        await db.query `CREATE SCHEMA IF NOT EXISTS "migrate-get-unique-constraints-test";`;
+    });
+    afterEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-unique-constraints-test" CASCADE;`;
+    });
+    test("with an empty database it returns no unique constraints", async () => {
+        const statement = getUniqueConstraints([
+            "migrate-get-unique-constraints-test",
+        ]);
+        const result = await db.query(statement);
+        expect(result).toEqual([]);
+    });
+    test("returns unique index constraints", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-unique-constraints-test"."users" (
+                        "id" SERIAL PRIMARY KEY,
+                        "email" TEXT NOT NULL
+                    );
+                `);
+            await db.query(sql `
+                    CREATE UNIQUE INDEX "idx_users_email" ON "migrate-get-unique-constraints-test"."users" ("email");
+                `);
+            const result = await db.query(getUniqueConstraints([
+                "migrate-get-unique-constraints-test",
+            ]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-unique-constraints-test",
+                    table: "users",
+                    name: "idx_users_email",
+                    definition: expect.stringContaining("CREATE UNIQUE INDEX idx_users_email"),
+                }),
+            ]);
+        }, { rollback: true });
+    });
+    test("returns composite unique index constraints", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-unique-constraints-test"."products" (
+                        "id" SERIAL PRIMARY KEY,
+                        "name" TEXT NOT NULL,
+                        "category" TEXT NOT NULL
+                    );
+                `);
+            await db.query(sql `
+                    CREATE UNIQUE INDEX "idx_products_name_category" ON "migrate-get-unique-constraints-test"."products" ("name", "category");
+                `);
+            const result = await db.query(getUniqueConstraints([
+                "migrate-get-unique-constraints-test",
+            ]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-unique-constraints-test",
+                    table: "products",
+                    name: "idx_products_name_category",
+                    definition: expect.stringContaining("CREATE UNIQUE INDEX idx_products_name_category"),
+                }),
+            ]);
+        }, { rollback: true });
+    });
+    test("excludes primary key constraints", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-unique-constraints-test"."users" (
+                        "id" SERIAL PRIMARY KEY,
+                        "email" TEXT UNIQUE
+                    );
+                `);
+            const result = await db.query(getUniqueConstraints([
+                "migrate-get-unique-constraints-test",
+            ]));
+            // Should only return the unique constraint on email, not the primary key
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual(expect.objectContaining({
+                schema: "migrate-get-unique-constraints-test",
+                table: "users",
+                definition: expect.stringContaining("email"),
+            }));
+            expect(result[0].definition).not.toContain("id");
+        }, { rollback: true });
+    });
+});

package/build/pull/index.d.ts

@@ -0,0 +1,4 @@
+export type { Column } from "./getColumns.js";
+export type { ForeignKey } from "./getForeignKeys.js";
+export type { PrimaryKey } from "./getPrimaryKeys.js";
+export type { UniqueConstraint } from "./getUniqueConstraints.js";

package/build/pull/index.js

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

package/build/pull/pullDefault.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalizes PostgreSQL default values to their canonical forms
+ * This is the inverse of renderDefault - it takes raw PostgreSQL defaults
+ * and converts them back to standard representations.
+ */
+export declare const pullDefault: (defaultValue: string | null) => string | null;

package/build/pull/pullDefault.js

@@ -0,0 +1,44 @@
+/**
+ * Normalizes PostgreSQL default values to their canonical forms
+ * This is the inverse of renderDefault - it takes raw PostgreSQL defaults
+ * and converts them back to standard representations.
+ */
+export const pullDefault = (defaultValue) => {
+    if (defaultValue === null) {
+        return null;
+    }
+    // Only convert when the default is literally "now()" - not timestamp literals
+    if (defaultValue === "now()") {
+        return "now()";
+    }
+    // Handle other common SQL functions that should remain as function calls
+    if (/^(gen_random_uuid|uuid_generate_v\d+|current_timestamp|current_date|current_time)\(\)$/.test(defaultValue)) {
+        return defaultValue;
+    }
+    // Handle nextval sequences (for serial types) - keep as-is
+    if (/^nextval\('.*'::regclass\)$/.test(defaultValue)) {
+        return defaultValue;
+    }
+    // Handle simple literals without type casting
+    if (/^'(.*)'::(text|varchar|char|bpchar)$/.test(defaultValue)) {
+        return defaultValue.replace(/^'(.*)'::(text|varchar|char|bpchar)$/, "'$1'");
+    }
+    // Handle numeric literals with type casting
+    if (/^'(.*)'::(numeric|decimal|real|double precision|float\d*|int\d*|smallint|bigint|integer)$/.test(defaultValue)) {
+        return defaultValue.replace(/^'(.*)'::(numeric|decimal|real|double precision|float\d*|int\d*|smallint|bigint|integer)$/, "$1");
+    }
+    // Handle boolean literals
+    if (defaultValue === "true" || defaultValue === "false") {
+        return defaultValue;
+    }
+    // Handle NULL with type casting
+    if (/^NULL::.+$/.test(defaultValue)) {
+        return null;
+    }
+    // Handle array literals - keep as-is since they're complex
+    if (/^(ARRAY\[.*\]|\{.*\})/.test(defaultValue)) {
+        return defaultValue;
+    }
+    // For everything else, return as-is
+    return defaultValue;
+};

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

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

package/build/pull/pullDefault.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "vitest";
+import { pullDefault } from "./pullDefault.js";
+describe("pullDefault", () => {
+    test("should return null for null values", () => {
+        expect(pullDefault(null)).toBe(null);
+    });
+    test("should preserve timestamp literals as-is", () => {
+        expect(pullDefault("'2025-06-28 15:02:55.251517'::timestamp without time zone")).toBe("'2025-06-28 15:02:55.251517'::timestamp without time zone");
+        expect(pullDefault("'2025-06-28 15:02:55.251517+00'::timestamptz")).toBe("'2025-06-28 15:02:55.251517+00'::timestamptz");
+        expect(pullDefault("'2023-01-01 12:00:00'::timestamp")).toBe("'2023-01-01 12:00:00'::timestamp");
+        expect(pullDefault("'2025-06-28 15:02:55'::timestamp with time zone")).toBe("'2025-06-28 15:02:55'::timestamp with time zone");
+    });
+    test("should preserve SQL function calls", () => {
+        expect(pullDefault("now()")).toBe("now()");
+        expect(pullDefault("gen_random_uuid()")).toBe("gen_random_uuid()");
+        expect(pullDefault("uuid_generate_v4()")).toBe("uuid_generate_v4()");
+        expect(pullDefault("current_timestamp()")).toBe("current_timestamp()");
+        expect(pullDefault("current_date()")).toBe("current_date()");
+        expect(pullDefault("current_time()")).toBe("current_time()");
+    });
+    test("should preserve nextval sequences for serial types", () => {
+        expect(pullDefault("nextval('user_id_seq'::regclass)")).toBe("nextval('user_id_seq'::regclass)");
+        expect(pullDefault("nextval('public.post_id_seq'::regclass)")).toBe("nextval('public.post_id_seq'::regclass)");
+    });
+    test("should handle text literals with type casting", () => {
+        expect(pullDefault("'hello'::text")).toBe("'hello'");
+        expect(pullDefault("'world'::varchar")).toBe("'world'");
+        expect(pullDefault("'test'::char")).toBe("'test'");
+        expect(pullDefault("'example'::bpchar")).toBe("'example'");
+    });
+    test("should handle numeric literals with type casting", () => {
+        expect(pullDefault("'123'::numeric")).toBe("123");
+        expect(pullDefault("'456'::integer")).toBe("456");
+        expect(pullDefault("'789'::bigint")).toBe("789");
+        expect(pullDefault("'12.34'::decimal")).toBe("12.34");
+        expect(pullDefault("'3.14'::real")).toBe("3.14");
+        expect(pullDefault("'2.718'::double precision")).toBe("2.718");
+        expect(pullDefault("'42'::smallint")).toBe("42");
+        expect(pullDefault("'99.99'::float4")).toBe("99.99");
+        expect(pullDefault("'88.88'::int4")).toBe("88.88");
+    });
+    test("should handle boolean literals", () => {
+        expect(pullDefault("true")).toBe("true");
+        expect(pullDefault("false")).toBe("false");
+    });
+    test("should handle NULL with type casting", () => {
+        expect(pullDefault("NULL::text")).toBe(null);
+        expect(pullDefault("NULL::integer")).toBe(null);
+        expect(pullDefault("NULL::timestamp")).toBe(null);
+    });
+    test("should preserve array literals", () => {
+        expect(pullDefault("ARRAY[1, 2, 3]")).toBe("ARRAY[1, 2, 3]");
+        expect(pullDefault("ARRAY['foo', 'bar']")).toBe("ARRAY['foo', 'bar']");
+        expect(pullDefault("ARRAY[ARRAY[ARRAY['a']]]")).toBe("ARRAY[ARRAY[ARRAY['a']]]");
+        expect(pullDefault("{1, 2, 3}")).toBe("{1, 2, 3}");
+        expect(pullDefault("{{foo, bar}, {baz, qux}}")).toBe("{{foo, bar}, {baz, qux}}");
+    });
+    test("should handle complex expressions as-is", () => {
+        expect(pullDefault('\'{"key": "value"}\'::jsonb')).toBe('\'{"key": "value"}\'::jsonb');
+        expect(pullDefault("'[]'::json")).toBe("'[]'::json");
+        expect(pullDefault("'happy'::mood")).toBe("'happy'::mood");
+        expect(pullDefault("'admin'::user_role")).toBe("'admin'::user_role");
+        expect(pullDefault("'(0,0)'::point")).toBe("'(0,0)'::point");
+        expect(pullDefault("'1 day'::interval")).toBe("'1 day'::interval");
+    });
+    test("should handle money defaults", () => {
+        expect(pullDefault("42.42")).toBe("42.42");
+        expect(pullDefault("$100.00")).toBe("$100.00");
+    });
+    test("should handle edge cases", () => {
+        expect(pullDefault("")).toBe("");
+        expect(pullDefault("0")).toBe("0");
+        expect(pullDefault("-1")).toBe("-1");
+        expect(pullDefault("'0'")).toBe("'0'");
+    });
+    test("should handle complex SQL expressions", () => {
+        // These should be preserved as-is since they're complex
+        expect(pullDefault("CASE WHEN foo = 'bar' THEN 1 ELSE 0 END")).toBe("CASE WHEN foo = 'bar' THEN 1 ELSE 0 END");
+        expect(pullDefault("COALESCE(column1, column2, 'default')")).toBe("COALESCE(column1, column2, 'default')");
+        expect(pullDefault("LENGTH('hello')")).toBe("LENGTH('hello')");
+    });
+});

package/build/pull.d.ts

@@ -0,0 +1,14 @@
+import { Orm } from "@casekit/orm";
+import { type Column } from "./pull/getColumns.js";
+import { type ForeignKey } from "./pull/getForeignKeys.js";
+import { type PrimaryKey } from "./pull/getPrimaryKeys.js";
+import { type UniqueConstraint } from "./pull/getUniqueConstraints.js";
+export type Table = {
+    schema: string;
+    name: string;
+    columns: Column[];
+    foreignKeys: ForeignKey[];
+    primaryKey: PrimaryKey | null;
+    uniqueConstraints: UniqueConstraint[];
+};
+export declare const pull: (db: Orm, schemas: string[]) => Promise<Table[]>;

package/build/pull.js

@@ -0,0 +1,56 @@
+import { orderBy } from "es-toolkit";
+import { getColumns } from "./pull/getColumns.js";
+import { getForeignKeys } from "./pull/getForeignKeys.js";
+import { getPrimaryKeys } from "./pull/getPrimaryKeys.js";
+import { getUniqueConstraints, } from "./pull/getUniqueConstraints.js";
+import { pullDefault } from "./pull/pullDefault.js";
+export const pull = async (db, schemas) => {
+    const [columns, foreignKeys, primaryKeys, uniqueConstraints] = await Promise.all([
+        db.query(getColumns(schemas)),
+        db.query(getForeignKeys(schemas)),
+        db.query(getPrimaryKeys(schemas)),
+        db.query(getUniqueConstraints(schemas)),
+    ]);
+    const tablesMap = new Map();
+    for (const column of orderBy(columns, ["ordinalPosition"], ["asc"])) {
+        const key = `${column.schema}.${column.table}`;
+        if (!tablesMap.has(key)) {
+            tablesMap.set(key, {
+                schema: column.schema,
+                name: column.table,
+                columns: [],
+                foreignKeys: [],
+                primaryKey: null,
+                uniqueConstraints: [],
+            });
+        }
+        // Normalize the default value using pullDefault
+        const normalizedColumn = {
+            ...column,
+            default: pullDefault(column.default),
+        };
+        tablesMap.get(key).columns.push(normalizedColumn);
+    }
+    for (const fk of foreignKeys) {
+        const key = `${fk.schema}.${fk.tableFrom}`;
+        const table = tablesMap.get(key);
+        if (table) {
+            table.foreignKeys.push(fk);
+        }
+    }
+    for (const pk of primaryKeys) {
+        const key = `${pk.schema}.${pk.table}`;
+        const table = tablesMap.get(key);
+        if (table) {
+            table.primaryKey = pk;
+        }
+    }
+    for (const uc of uniqueConstraints) {
+        const key = `${uc.schema}.${uc.table}`;
+        const table = tablesMap.get(key);
+        if (table) {
+            table.uniqueConstraints.push(uc);
+        }
+    }
+    return orderBy(Array.from(tablesMap.values()), ["schema", "name"], ["asc", "asc"]);
+};

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/orm";
+export declare const createExtensionsSql: (schema: string, extension: string) => SQLStatement;

package/build/push/createExtensionSql.js

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

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/orm";
+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("foo", "uuid-ossp");
+        expect(statement.text).toEqual('CREATE EXTENSION IF NOT EXISTS "uuid-ossp" SCHEMA "foo";');
+        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/orm";
+import { NormalizedForeignKeyDefinition, NormalizedModelDefinition } from "@casekit/orm-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/orm";
+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 {};