@casekit/orm-migrate 0.0.1-release-candidate

package/build/drop.d.ts

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

package/build/drop.js

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

package/build/index.d.ts

@@ -0,0 +1,7 @@
+export declare const migrate: {
+    drop: (db: import("@casekit/orm").Orm) => Promise<void>;
+    push: (db: import("@casekit/orm").Orm) => Promise<void>;
+    pull: (db: import("@casekit/orm").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/index.js

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

package/build/pull/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/orm").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/getColumns.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { sql } from "@casekit/orm";
+export const ColumnSchema = z.object({
+    schema: z.string(),
+    table: z.string(),
+    column: z.string(),
+    ordinalPosition: z.number().nullable(),
+    type: z.string(),
+    default: z.string().nullable(),
+    nullable: z.boolean(),
+    udtSchema: z.string(),
+    udt: z.string(),
+    elementType: z.string().nullable(),
+    elementTypeSchema: z.string().nullable(),
+    cardinality: z.number(),
+    size: z.number().nullable(),
+    isSerial: z.boolean(),
+});
+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",
+            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",
+            c.udt_name AS "udt",
+            e.data_type AS "elementType",
+            e.udt_schema AS "elementTypeSchema",
+            pa.attndims AS cardinality,
+            c.character_maximum_length AS "size",
+            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
+                AND t.table_schema = c.table_schema
+                AND t.table_catalog = c.table_catalog
+            JOIN pg_catalog.pg_class pc ON pc.relname = c.table_name
+            JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace
+                AND pn.nspname = c.table_schema
+            JOIN pg_catalog.pg_attribute pa ON pa.attrelid = pc.oid
+                AND pa.attname = c.column_name
+            LEFT JOIN information_schema.element_types e ON c.table_catalog = e.object_catalog
+                AND c.table_schema = e.object_schema
+                AND c.table_name = e.object_name
+                AND e.object_type = 'TABLE'
+                AND e.collection_type_identifier = c.dtd_identifier
+                AND c.data_type = 'ARRAY'
+            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'
+            AND pa.attnum > 0
+        ORDER BY
+            t.table_name,
+            c.ordinal_position
+    `;

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

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

package/build/pull/getColumns.test.js

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

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

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/orm";
+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/orm").SQLStatement<{
+    schema: string;
+    table: string;
+    constraintName: string;
+    columns: string[];
+}>;