@casekit/orm2-migrate 0.0.0-20250331202540 → 0.0.0

package/build/index.d.ts

@@ -1,19 +1,7 @@
 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<{
-        schema: string;
-        table: string;
-        column: string;
-        ordinalPosition: number | null;
-        type: string;
-        default: string | null;
-        nullable: boolean;
-        udtSchema: string;
-        udt: string;
-        elementType: string | null;
-        elementTypeSchema: string | null;
-        cardinality: number;
-        size: number | null;
-    }[]>;
+    pull: (db: import("@casekit/orm2").Orm, schemas: string[]) => Promise<import("#pull.js").Table[]>;
 };
+export type { Table } from "#pull.js";
+export type { Column, ForeignKey, PrimaryKey, UniqueConstraint, } from "#pull/index.js";

package/build/pull/getColumns.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export declare const ColumnSchema: 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>;
+    isSerial: z.ZodBoolean;
+}, z.core.$strip>;
+export type Column = z.infer<typeof ColumnSchema>;
+export declare const getColumns: (schemas: string[]) => import("@casekit/orm2").SQLStatement<{
+    schema: string;
+    table: string;
+    column: string;
+    ordinalPosition: number | null;
+    type: string;
+    default: string | null;
+    nullable: boolean;
+    udtSchema: string;
+    udt: string;
+    elementType: string | null;
+    elementTypeSchema: string | null;
+    cardinality: number;
+    size: number | null;
+    isSerial: boolean;
+}>;

package/build/pull/{getTables.js → getColumns.js}

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { sql } from "@casekit/orm2";
-export const TableColumnSchema = z.object({
+export const ColumnSchema = z.object({
     schema: z.string(),
     table: z.string(),
     column: z.string(),
@@ -14,14 +14,20 @@ export const TableColumnSchema = z.object({
     elementTypeSchema: z.string().nullable(),
     cardinality: z.number(),
     size: z.number().nullable(),
+    isSerial: z.boolean(),
 });
-export const getTables = (schemas) => sql(TableColumnSchema) `
+export const getColumns = (schemas) => sql(ColumnSchema) `
         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",
+            CASE 
+                WHEN c.udt_name = 'int2vector' THEN 'int2vector'
+                WHEN c.udt_name = 'oidvector' THEN 'oidvector'
+                WHEN c.data_type = 'ARRAY' AND c.udt_name LIKE '\_int2vector' THEN 'int2vector[]'
+                ELSE c.data_type
+            END AS "type",
             c.column_default AS "default",
             c.is_nullable = 'YES' AS "nullable",
             c.udt_schema AS "udtSchema",
@@ -29,7 +35,8 @@ export const getTables = (schemas) => sql(TableColumnSchema) `
             e.data_type AS "elementType",
             e.udt_schema AS "elementTypeSchema",
             pa.attndims AS cardinality,
-            c.character_maximum_length AS "size"
+            c.character_maximum_length AS "size",
+            COALESCE(seq_owned.is_serial, false) AS "isSerial"
         FROM
             information_schema.tables t
             JOIN information_schema.columns c ON t.table_name = c.table_name
@@ -46,6 +53,26 @@ export const getTables = (schemas) => sql(TableColumnSchema) `
                 AND e.object_type = 'TABLE'
                 AND e.collection_type_identifier = c.dtd_identifier
                 AND c.data_type = 'ARRAY'
+            LEFT JOIN (
+                SELECT 
+                    pn.nspname AS schema_name,
+                    pc.relname AS table_name,
+                    pa.attname AS column_name,
+                    true AS is_serial
+                FROM 
+                    pg_depend pd
+                    JOIN pg_class pc ON pd.refobjid = pc.oid AND pc.relkind = 'r'
+                    JOIN pg_attribute pa ON pd.refobjid = pa.attrelid AND pd.refobjsubid = pa.attnum
+                    JOIN pg_namespace pn ON pc.relnamespace = pn.oid
+                    JOIN pg_class seq ON pd.objid = seq.oid AND seq.relkind = 'S'
+                WHERE 
+                    pd.deptype = 'a'
+                    AND pd.classid = 'pg_class'::regclass
+                    AND pd.refclassid = 'pg_class'::regclass
+                    AND pn.nspname IN (${schemas})
+            ) seq_owned ON seq_owned.schema_name = c.table_schema 
+                AND seq_owned.table_name = c.table_name 
+                AND seq_owned.column_name = c.column_name
         WHERE
             t.table_schema IN (${schemas})
             AND t.table_type = 'BASE TABLE'

package/build/pull/{getTables.test.js → getColumns.test.js}

@@ -1,7 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, } from "vitest";
 import { orm, sql } from "@casekit/orm2";
-import { getTables } from "./getTables.js";
-describe("getTables", () => {
+import { getColumns } from "./getColumns.js";
+describe("getColumns", () => {
     const db = orm({
         schema: "migrate-get-tables-test",
         models: {},
@@ -20,7 +20,7 @@ describe("getTables", () => {
         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 statement = getColumns(["migrate-get-tables-test"]);
         const result = await db.query(statement);
         expect(result).toEqual([]);
     });
@@ -59,16 +59,19 @@ describe("getTables", () => {
                     type: "smallint",
                     default: expect.stringContaining("nextval"),
                     nullable: false,
+                    isSerial: true,
                 }),
                 expect.objectContaining({
                     type: "integer",
                     default: expect.stringContaining("nextval"),
                     nullable: false,
+                    isSerial: true,
                 }),
                 expect.objectContaining({
                     type: "bigint",
                     default: expect.stringContaining("nextval"),
                     nullable: false,
+                    isSerial: true,
                 }),
             ],
         ],
@@ -288,10 +291,29 @@ describe("getTables", () => {
                 expect.objectContaining({ type: "macaddr" }),
             ],
         ],
+        [
+            "handles sql now() default values correctly",
+            sql `
+                CREATE TABLE "migrate-get-tables-test"."timestamp_defaults_test" (
+                    "created_at" TIMESTAMP DEFAULT now(),
+                    "updated_at" TIMESTAMP WITH TIME ZONE DEFAULT now()
+                );
+            `,
+            [
+                expect.objectContaining({
+                    type: "timestamp without time zone",
+                    default: "now()",
+                }),
+                expect.objectContaining({
+                    type: "timestamp with time zone",
+                    default: "now()",
+                }),
+            ],
+        ],
     ])("%s", async ([_, query, expected]) => {
         await db.transact(async (db) => {
             await db.query(query);
-            const result = await db.query(getTables(["migrate-get-tables-test"]));
+            const result = await db.query(getColumns(["migrate-get-tables-test"]));
             expect(result).toEqual(expected);
         }, { rollback: true });
     });

package/build/pull/getForeignKeys.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const ForeignKeySchema: z.ZodObject<{
+    schema: z.ZodString;
+    constraintName: z.ZodString;
+    tableFrom: z.ZodString;
+    columnsFrom: z.ZodArray<z.ZodString>;
+    tableTo: z.ZodString;
+    columnsTo: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ForeignKey = z.infer<typeof ForeignKeySchema>;
+export declare const getForeignKeys: (schemas: string[]) => import("@casekit/orm2").SQLStatement<{
+    schema: string;
+    constraintName: string;
+    tableFrom: string;
+    columnsFrom: string[];
+    tableTo: string;
+    columnsTo: string[];
+}>;

package/build/pull/getForeignKeys.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { sql } from "@casekit/orm2";
+export const ForeignKeySchema = z.object({
+    schema: z.string(),
+    constraintName: z.string(),
+    tableFrom: z.string(),
+    columnsFrom: z.array(z.string()),
+    tableTo: z.string(),
+    columnsTo: z.array(z.string()),
+});
+export const getForeignKeys = (schemas) => sql(ForeignKeySchema) `
+        SELECT
+            nspname AS "schema",
+            conname AS "constraintName",
+            table_from AS "tableFrom",
+            array_agg(columns_from::text ORDER BY ordinality) AS "columnsFrom",
+            table_to AS "tableTo",
+            array_agg(columns_to::text ORDER BY ordinality) AS "columnsTo"
+        FROM (
+            SELECT
+                conname,
+                c.relname AS table_from,
+                a.attname AS columns_from,
+                cf.relname AS table_to,
+                af.attname AS columns_to,
+                n.nspname,
+                ss2.ordinality
+            FROM
+                pg_attribute AS af,
+                pg_attribute AS a,
+                pg_class c,
+                pg_class cf,
+                pg_namespace n,
+                (
+                    SELECT
+                        conname,
+                        conrelid,
+                        confrelid,
+                        conkey[i] AS conkey,
+                        confkey[i] AS confkey,
+                        i AS ordinality
+                    FROM (
+                        SELECT
+                            conname,
+                            conrelid,
+                            confrelid,
+                            conkey,
+                            confkey,
+                            generate_series(1, array_upper(conkey, 1)) AS i
+                        FROM
+                            pg_constraint
+                        WHERE
+                            contype = 'f') AS ss) AS ss2
+                WHERE
+                    af.attnum = confkey
+                    AND af.attrelid = confrelid
+                    AND a.attnum = conkey
+                    AND a.attrelid = conrelid
+                    AND a.attrelid = c.oid
+                    AND af.attrelid = cf.oid
+                    AND c.relnamespace = n.oid
+                    AND n.nspname IN (${schemas})) AS ss3
+        GROUP BY
+            nspname,
+            conname,
+            table_to,
+            table_from
+        ORDER BY
+            nspname,
+            table_from,
+            conname
+    `;

package/build/pull/getForeignKeys.test.js

@@ -0,0 +1,86 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, } from "vitest";
+import { orm, sql } from "@casekit/orm2";
+import { getForeignKeys } from "./getForeignKeys.js";
+describe("getForeignKeys", () => {
+    const db = orm({
+        schema: "migrate-get-foreign-keys-test",
+        models: {},
+    });
+    beforeAll(async () => {
+        await db.connect();
+    });
+    afterAll(async () => {
+        await db.close();
+    });
+    beforeEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-foreign-keys-test" CASCADE;`;
+        await db.query `CREATE SCHEMA IF NOT EXISTS "migrate-get-foreign-keys-test";`;
+    });
+    afterEach(async () => {
+        await db.query `DROP SCHEMA IF EXISTS "migrate-get-foreign-keys-test" CASCADE;`;
+    });
+    test("with an empty database it returns no foreign keys", async () => {
+        const statement = getForeignKeys(["migrate-get-foreign-keys-test"]);
+        const result = await db.query(statement);
+        expect(result).toEqual([]);
+    });
+    test("returns foreign key relationships", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-foreign-keys-test"."users" (
+                        "id" SERIAL PRIMARY KEY,
+                        "name" TEXT NOT NULL
+                    );
+                `);
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-foreign-keys-test"."posts" (
+                        "id" SERIAL PRIMARY KEY,
+                        "title" TEXT NOT NULL,
+                        "user_id" INTEGER NOT NULL,
+                        CONSTRAINT "fk_posts_user_id" FOREIGN KEY ("user_id") REFERENCES "migrate-get-foreign-keys-test"."users" ("id")
+                    );
+                `);
+            const result = await db.query(getForeignKeys(["migrate-get-foreign-keys-test"]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-foreign-keys-test",
+                    constraintName: "fk_posts_user_id",
+                    tableFrom: "posts",
+                    columnsFrom: ["user_id"],
+                    tableTo: "users",
+                    columnsTo: ["id"],
+                }),
+            ]);
+        }, { rollback: true });
+    });
+    test("handles composite foreign keys", async () => {
+        await db.transact(async (db) => {
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-foreign-keys-test"."companies" (
+                        "id" INTEGER NOT NULL,
+                        "code" TEXT NOT NULL,
+                        PRIMARY KEY ("id", "code")
+                    );
+                `);
+            await db.query(sql `
+                    CREATE TABLE "migrate-get-foreign-keys-test"."employees" (
+                        "id" SERIAL PRIMARY KEY,
+                        "company_id" INTEGER NOT NULL,
+                        "company_code" TEXT NOT NULL,
+                        CONSTRAINT "fk_employees_company" FOREIGN KEY ("company_id", "company_code") REFERENCES "migrate-get-foreign-keys-test"."companies" ("id", "code")
+                    );
+                `);
+            const result = await db.query(getForeignKeys(["migrate-get-foreign-keys-test"]));
+            expect(result).toEqual([
+                expect.objectContaining({
+                    schema: "migrate-get-foreign-keys-test",
+                    constraintName: "fk_employees_company",
+                    tableFrom: "employees",
+                    columnsFrom: ["company_id", "company_code"],
+                    tableTo: "companies",
+                    columnsTo: ["id", "code"],
+                }),
+            ]);
+        }, { rollback: true });
+    });
+});

package/build/pull/getPrimaryKeys.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const PrimaryKeySchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodString;
+    constraintName: z.ZodString;
+    columns: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type PrimaryKey = z.infer<typeof PrimaryKeySchema>;
+export declare const getPrimaryKeys: (schemas: string[]) => import("@casekit/orm2").SQLStatement<{
+    schema: string;
+    table: string;
+    constraintName: string;
+    columns: string[];
+}>;

package/build/pull/getPrimaryKeys.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { sql } from "@casekit/orm2";
+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/orm2";
+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/orm2").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/orm2";
+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/orm2";
+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

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

@@ -1,4 +1,56 @@
-import { getTables } from "./pull/getTables.js";
+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) => {
-    return await db.query(getTables(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/createTableSql.test.js

@@ -79,6 +79,17 @@ describe("createTableSql", () => {
                 );
             `,
         ],
+        [
+            "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: {

package/package.json

@@ -1,33 +1,34 @@
 {
   "name": "@casekit/orm2-migrate",
   "description": "",
-  "version": "0.0.0-20250331202540",
+  "version": "0.0.0",
   "author": "",
   "dependencies": {
     "camelcase": "^8.0.0",
-    "@casekit/orm2": "0.0.0-20250331202540",
-    "@casekit/orm2-schema": "0.0.0-20250331202540",
-    "@casekit/orm2-config": "0.0.0-20250331202540",
-    "@casekit/sql": "0.0.0-20250331202540",
-    "@casekit/toolbox": "0.0.0-20250331202540"
+    "es-toolkit": "^1.39.3",
+    "@casekit/orm2": "0.0.0",
+    "@casekit/orm2-config": "0.0.0",
+    "@casekit/sql": "0.0.0",
+    "@casekit/toolbox": "0.0.0",
+    "@casekit/orm2-schema": "0.0.0"
   },
   "devDependencies": {
     "@casekit/unindent": "^1.0.5",
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@types/node": "^22.13.13",
-    "@types/pg": "^8.11.11",
+    "@types/node": "^24.0.3",
+    "@types/pg": "^8.15.4",
     "@types/uuid": "^10.0.0",
-    "@vitest/coverage-v8": "^3.0.9",
-    "dotenv": "^16.4.7",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^16.5.0",
     "prettier": "^3.5.3",
-    "prettier-plugin-svelte": "^3.3.3",
-    "typescript": "^5.8.2",
+    "prettier-plugin-svelte": "^3.4.0",
+    "typescript": "^5.8.3",
     "uuid": "^11.1.0",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.9",
-    "@casekit/orm2-fixtures": "0.0.0-20250331202540",
-    "@casekit/prettier-config": "0.0.0-20250331202540",
-    "@casekit/tsconfig": "0.0.0-20250331202540"
+    "vitest": "^3.2.4",
+    "@casekit/orm2-fixtures": "0.0.0",
+    "@casekit/tsconfig": "0.0.0",
+    "@casekit/prettier-config": "0.0.0"
   },
   "exports": {
     ".": "./build/index.js"
@@ -40,10 +41,9 @@
   },
   "keywords": [],
   "license": "ISC",
-  "main": "index.js",
   "peerDependencies": {
     "pg": "^8.13.1",
-    "zod": "^3.24.2"
+    "zod": "^4.0.17"
   },
   "prettier": "@casekit/prettier-config",
   "type": "module",

package/build/pull/getTables.d.ts

@@ -1,60 +0,0 @@
-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, {
-    schema: string;
-    table: string;
-    column: string;
-    ordinalPosition: number | null;
-    type: string;
-    default: string | null;
-    nullable: boolean;
-    udtSchema: string;
-    udt: string;
-    elementType: string | null;
-    elementTypeSchema: string | null;
-    cardinality: number;
-    size: number | null;
-}, {
-    schema: string;
-    table: string;
-    column: string;
-    ordinalPosition: number | null;
-    type: string;
-    default: string | null;
-    nullable: boolean;
-    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<{
-    schema: string;
-    table: string;
-    column: string;
-    ordinalPosition: number | null;
-    type: string;
-    default: string | null;
-    nullable: boolean;
-    udtSchema: string;
-    udt: string;
-    elementType: string | null;
-    elementTypeSchema: string | null;
-    cardinality: number;
-    size: number | null;
-}>;

package/build/render/renderDefault.d.ts

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

package/build/render/renderDefault.js

@@ -1,12 +0,0 @@
-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.js

@@ -1,23 +0,0 @@
-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

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

package/build/render/renderModel.js

@@ -1,35 +0,0 @@
-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;
-    `;
-};