@casekit/orm2-config 0.0.0-20250322230249

package/build/index.d.ts

@@ -0,0 +1,11 @@
+export { normalizeConfig } from "./normalize/normalizeConfig.js";
+export { normalizeModel } from "./normalize/normalizeModel.js";
+export { normalizeUniqueConstraint } from "./normalize/normalizeUniqueConstraints.js";
+export type { NormalizedConfig } from "./types/NormalizedConfig.js";
+export type { NormalizedFieldDefinition } from "./types/NormalizedFieldDefinition.js";
+export type { NormalizedForeignKeyDefinition } from "./types/NormalizedForeignKeyDefinition.js";
+export type { NormalizedModelDefinition } from "./types/NormalizedModelDefinition.js";
+export type { NormalizedPrimaryKey } from "./types/NormalizedPrimaryKey.js";
+export type { NormalizedManyToManyRelationDefinition, NormalizedManyToOneRelationDefinition, NormalizedOneToManyRelationDefinition, NormalizedRelationDefinition, } from "./types/NormalizedRelationDefinition.js";
+export type { NormalizedUniqueConstraintDefinition } from "./types/NormalizedUniqueConstraintDefinition.js";
+export { getField, getModel, getRelation } from "./util.js";

package/build/index.js

@@ -0,0 +1,4 @@
+export { normalizeConfig } from "./normalize/normalizeConfig.js";
+export { normalizeModel } from "./normalize/normalizeModel.js";
+export { normalizeUniqueConstraint } from "./normalize/normalizeUniqueConstraints.js";
+export { getField, getModel, getRelation } from "./util.js";

package/build/normalize/defaultZodSchema.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/**
+ * WARNING!!! The schemas in this file must be kept in sync
+ * with DefaultFieldType in packages/orm-schema/src/helper/DefaultFieldType.ts.
+ * If you make a change here, make sure to update the
+ * corresponding type.
+ */
+export declare const defaultZodSchema: (type: string) => z.ZodSchema<unknown>;

package/build/normalize/defaultZodSchema.js

@@ -0,0 +1,127 @@
+import { z } from "zod";
+/**
+ * WARNING!!! The schemas in this file must be kept in sync
+ * with DefaultFieldType in packages/orm-schema/src/helper/DefaultFieldType.ts.
+ * If you make a change here, make sure to update the
+ * corresponding type.
+ */
+export const defaultZodSchema = (type) => {
+    if (type.endsWith("[]"))
+        return z.array(defaultZodSchema(type.slice(0, -2)));
+    if (type.startsWith("bit "))
+        return z.string();
+    if (type.startsWith("bit("))
+        return z.string();
+    if (type.startsWith("character varying"))
+        return z.string();
+    if (type.startsWith("character"))
+        return z.string();
+    if (type.startsWith("numeric "))
+        return z.string();
+    if (type.startsWith("numeric("))
+        return z.string();
+    if (type.startsWith("timestamp "))
+        return z.date();
+    if (type.startsWith("timestamp("))
+        return z.date();
+    if (type.startsWith("time "))
+        return z.string();
+    if (type.startsWith("time("))
+        return z.string();
+    if (type.startsWith("varchar "))
+        return z.string();
+    if (type.startsWith("varchar("))
+        return z.string();
+    // if (type.startsWith("interval"))
+    //     return z.object({
+    //         years: z.number().optional(),
+    //         months: z.number().optional(),
+    //         days: z.number().optional(),
+    //         hours: z.number().optional(),
+    //         minutes: z.number().optional(),
+    //         seconds: z.number().optional(),
+    //         milliseconds: z.number().optional(),
+    //     });
+    switch (type) {
+        case "bigint":
+        case "bigserial":
+            return z.coerce.bigint();
+        case "decimal":
+        case "double precision":
+        case "integer":
+        case "oid":
+        case "real":
+        case "smallint":
+        case "smallserial":
+        case "serial":
+            return z.number();
+        case "bpchar":
+        case "bit":
+        case "box":
+        case "cidr":
+        case "daterange":
+        case "inet":
+        case "int4range":
+        case "int8range":
+        case "int2vector":
+        case "pg_lsn":
+        case "regclass":
+        case "regconfig":
+        case "regdictionary":
+        case "regnamespace":
+        case "regoper":
+        case "regoperator":
+        case "regproc":
+        case "regprocedure":
+        case "regrole":
+        case "regtype":
+        case "tid":
+        case "xid":
+        case "numrange":
+        case "tsrange":
+        case "tstzrange":
+        case "line":
+        case "lseg":
+        case "macaddr":
+        case "macaddr8":
+        case "money":
+        case "numeric":
+        case "path":
+        case "polygon":
+        case "text":
+        case "time":
+        case "timetz":
+        case "tsquery":
+        case "tsvector":
+        case "txid_snapshot":
+        case "varchar":
+        case "char":
+        case "xml":
+            return z.string();
+        case "bytea":
+            return z.instanceof(Buffer);
+        // case "circle":
+        //     return z.object({
+        //         x: z.number(),
+        //         y: z.number(),
+        //         radius: z.number(),
+        //     });
+        // case "point":
+        //     return z.object({ x: z.number(), y: z.number() });
+        case "json":
+        case "jsonb":
+            return z.record(z.any());
+        case "uuid":
+            return z.string().uuid();
+        case "boolean":
+            return z.boolean();
+        case "date":
+        case "timestamp":
+        case "timestamptz":
+            return z.date();
+        default:
+            throw new Error("Unsupported type: " +
+                type +
+                " - please specify a zod schema in the field definition");
+    }
+};

package/build/normalize/defaultZodSchema.test.d.ts

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

package/build/normalize/defaultZodSchema.test.js

@@ -0,0 +1,153 @@
+import pg from "pg";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+import { defaultZodSchema } from "./defaultZodSchema.js";
+describe("defaultZodSchema", () => {
+    let db;
+    beforeAll(async () => {
+        db = new pg.Client();
+        await db.connect();
+    });
+    afterEach(async () => {
+        await db.query("ROLLBACK");
+    });
+    afterAll(async () => {
+        await db.end();
+    });
+    test.for([
+        ["char", "a", "a"],
+        ["character", "a", "a"],
+        ["character(24)", "abc", "abc                     "],
+        ["character varying", "abc", "abc"],
+        ["character varying(24)", "abc", "abc"],
+        ["varchar", "abc", "abc"],
+        ["bit", "1", "1"],
+        ["bit", "0", "0"],
+        ["bit(3)", "101", "101"],
+        ["bit varying", "101", "101"],
+        ["numeric", 123, "123"],
+        ["numeric(5,2)", 123.45, "123.45"],
+        ["numeric (5,2)", 123.45, "123.45"],
+        ["integer", 42, 42],
+        ["bigint", "9007199254740991", 9007199254740991n],
+        ["double precision", 3.14159, 3.14159],
+        ["real", 3.14, 3.14],
+        ["text", "hello world", "hello world"],
+        [
+            "uuid",
+            "123e4567-e89b-12d3-a456-426614174000",
+            "123e4567-e89b-12d3-a456-426614174000",
+        ],
+        ["boolean", true, true],
+        ["bpchar", "abc", "abc"],
+        ["date", "2023-01-01", new Date("2023-01-01")],
+        ["timetz", "13:45:30", "13:45:30+00"],
+        ["timestamptz", "2023-01-01 13:45:30", new Date("2023-01-01T13:45:30")],
+        ["time", "13:45:30", "13:45:30"],
+        ["time(3)", "13:45:30", "13:45:30"],
+        ["timestamp", "2023-01-01 13:45:30", new Date("2023-01-01T13:45:30")],
+        [
+            "timestamp(6)",
+            "2023-01-01 13:45:30",
+            new Date("2023-01-01T13:45:30"),
+        ],
+        // ["interval", "1 year 2 months", { months: 2, years: 1 }],
+        // [
+        //     "interval",
+        //     "3 days 12 hours 7 minutes 2 seconds 555 milliseconds",
+        //     {
+        //         days: 3,
+        //         hours: 12,
+        //         minutes: 7,
+        //         seconds: 2,
+        //         milliseconds: 555,
+        //     },
+        // ],
+        ["json", '{"key":"value"}', { key: "value" }],
+        ["jsonb", '{"key":"value"}', { key: "value" }],
+        // ["point", "(1,2)", { x: 1, y: 2 }],
+        ["line", "{1,2,3}", "{1,2,3}"],
+        ["lseg", "((1,2),(3,4))", "[(1,2),(3,4)]"],
+        ["box", "(3,4),(1,2)", "(3,4),(1,2)"],
+        ["polygon", "((1,2),(3,4),(5,6))", "((1,2),(3,4),(5,6))"],
+        // ["circle", "<(1,2),3>", { x: 1, y: 2, radius: 3 }],
+        ["cidr", "192.168.100.128/25", "192.168.100.128/25"],
+        ["inet", "192.168.100.128", "192.168.100.128"],
+        ["macaddr", "08:00:2b:01:02:03", "08:00:2b:01:02:03"],
+        ["macaddr8", "08:00:2b:01:02:03:04:05", "08:00:2b:01:02:03:04:05"],
+        ["bit varying(3)", "101", "101"],
+        ["smallint", 32767, 32767],
+        ["serial", undefined, 1],
+        ["bigserial", undefined, 1n],
+        ["smallserial", undefined, 1],
+        ["money", 19.99, "$19.99"],
+        [
+            "timestamp with time zone",
+            "2023-01-01 13:45:30+00",
+            new Date("2023-01-01T13:45:30Z"),
+        ],
+        ["time with time zone", "13:45:30+00", "13:45:30+00"],
+        ["bytea", Buffer.from("hello"), Buffer.from("hello")],
+        ["xml", "<root>test</root>", "<root>test</root>"],
+        ["path", "((1,2),(3,4),(5,6))", "((1,2),(3,4),(5,6))"],
+        ["tsquery", "'fat' & 'rat'", "'fat' & 'rat'"],
+        [
+            "tsvector",
+            "a fat cat sat on a mat",
+            "'a' 'cat' 'fat' 'mat' 'on' 'sat'",
+        ],
+        ["int4range", "[1,4)", "[1,4)"],
+        ["int8range", "[1,9223372036854775807)", "[1,9223372036854775807)"],
+        ["numrange", "[1.123,4.456)", "[1.123,4.456)"],
+        [
+            "tsrange",
+            "[2023-01-01 00:00:00,2023-01-02 00:00:00)",
+            `["2023-01-01 00:00:00","2023-01-02 00:00:00")`,
+        ],
+        [
+            "tstzrange",
+            "[2023-01-01 00:00:00+00,2023-01-02 00:00:00+00)",
+            `["2023-01-01 00:00:00+00","2023-01-02 00:00:00+00")`,
+        ],
+        ["daterange", "[2023-01-01,2023-01-02)", "[2023-01-01,2023-01-02)"],
+        ["int2vector", "1 2 3", "1 2 3"],
+        ["oid", "1234", 1234],
+        ["pg_lsn", "0/1234567", "0/1234567"],
+        ["regclass", "pg_class", "pg_class"],
+        ["regnamespace", "pg_catalog", "pg_catalog"],
+        ["regproc", "now", "now"],
+        ["regprocedure", "sum(integer)", "sum(integer)"],
+        ["regrole", "orm", "orm"],
+        ["regtype", "integer", "integer"],
+        ["tid", "(0,1)", "(0,1)"],
+        ["xid", "1234", "1234"],
+        ["txid_snapshot", "10:20:10,14,15", "10:20:10,14,15"],
+        [
+            "text[][][]",
+            "{{{a,b},{c,d}},{{e,f},{g,h}}}",
+            [
+                [
+                    ["a", "b"],
+                    ["c", "d"],
+                ],
+                [
+                    ["e", "f"],
+                    ["g", "h"],
+                ],
+            ],
+        ],
+    ])("%s columns", async ([datatype, value, expected = value]) => {
+        await db.query("BEGIN TRANSACTION");
+        await db.query(`CREATE TABLE foo (value ${datatype})`);
+        if (datatype.endsWith("serial")) {
+            await db.query("INSERT INTO foo DEFAULT VALUES");
+        }
+        else {
+            await db.query(`INSERT INTO foo (value) VALUES ($1::${datatype})`, [
+                value,
+            ]);
+        }
+        const result = await db.query(`SELECT * FROM foo`);
+        const parsed = defaultZodSchema(datatype).parse(result.rows[0]?.value);
+        expect(parsed).toEqual(expected);
+    });
+});

package/build/normalize/getColumns.d.ts

@@ -0,0 +1,2 @@
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+export declare const getColumns: (model: PopulatedModelDefinition, fields: string[]) => string[];

package/build/normalize/getColumns.js

@@ -0,0 +1,8 @@
+export const getColumns = (model, fields) => {
+    return fields.map((f) => {
+        if (!model.fields[f]) {
+            throw new Error(`Field "${f}" not found in model "${model.name}"`);
+        }
+        return model.fields[f].column;
+    });
+};

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

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

package/build/normalize/getColumns.test.js

@@ -0,0 +1,63 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { getColumns } from "./getColumns.js";
+import { populateModels } from "./populateModels.js";
+describe("getColumns", () => {
+    test("returns column names for given fields", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        fullName: { type: "text" },
+                        emailAddress: { type: "text" },
+                    },
+                },
+            },
+        });
+        expect(getColumns(models["user"], ["id", "fullName", "emailAddress"])).toEqual(["id", "full_name", "email_address"]);
+    });
+    test("throws error for non-existent field", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        expect(() => getColumns(models["user"], ["id", "nonexistent"])).toThrow('Field "nonexistent" not found in model "user"');
+    });
+    test("returns empty array for empty fields array", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        expect(getColumns(models["user"], [])).toEqual([]);
+    });
+    test("handles custom column names", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        name: { type: "text", column: "user_full_name" },
+                    },
+                },
+            },
+        });
+        expect(getColumns(models["user"], ["id", "name"])).toEqual([
+            "id",
+            "user_full_name",
+        ]);
+    });
+});

package/build/normalize/normalizeConfig.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "@casekit/orm2-schema";
+import { NormalizedConfig } from "#types/NormalizedConfig.js";
+export declare const normalizeConfig: (config: Config) => NormalizedConfig;

package/build/normalize/normalizeConfig.js

@@ -0,0 +1,20 @@
+import { identity, mapValues } from "es-toolkit";
+import { normalizeModel } from "./normalizeModel.js";
+import { populateModels } from "./populateModels.js";
+export const normalizeConfig = (config) => {
+    const models = populateModels(config);
+    return {
+        ...config,
+        schema: config.schema ?? "public",
+        models: mapValues(models, (model) => normalizeModel(models, model)),
+        operators: config.operators ?? { where: {} },
+        extensions: config.extensions ?? [],
+        connection: config.connection ?? null,
+        pool: config.pool ?? false,
+        logger: config.logger ?? console,
+        naming: {
+            column: config.naming?.column ?? identity,
+            table: config.naming?.table ?? identity,
+        },
+    };
+};

package/build/normalize/normalizeConfig.test.d.ts

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

package/build/normalize/normalizeConfig.test.js

@@ -0,0 +1,217 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import { sql } from "@casekit/sql";
+import { normalizeConfig } from "./normalizeConfig.js";
+describe("normalizeConfig", () => {
+    test("normalizes minimal config with defaults", () => {
+        const config = {
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        name: { type: "text" },
+                    },
+                },
+            },
+        };
+        const result = normalizeConfig(config);
+        expect(result.schema).toBe("public");
+        expect(result.operators).toEqual({ where: {} });
+        expect(result.extensions).toEqual([]);
+        expect(result.connection).toBeNull();
+        expect(result.pool).toBe(false);
+        expect(result.logger).toBe(console);
+        expect(typeof result.naming.column).toBe("function");
+        expect(typeof result.naming.table).toBe("function");
+        // Test that default identity functions don't transform names
+        expect(result.naming.column("userName")).toBe("userName");
+        expect(result.naming.table("UserProfile")).toBe("UserProfile");
+    });
+    test("preserves provided config values", () => {
+        const customLogger = {
+            debug: () => {
+                /* empty */
+            },
+            info: () => {
+                /* empty  */
+            },
+            warn: () => {
+                /* empty */
+            },
+            error: () => {
+                /* empty */
+            },
+        };
+        const $contains = Symbol("contains");
+        const config = {
+            schema: "custom",
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+            operators: {
+                where: {
+                    [$contains]: () => sql ``,
+                },
+            },
+            extensions: ["uuid-ossp"],
+            connection: {
+                host: "localhost",
+                database: "test",
+            },
+            pool: true,
+            logger: customLogger,
+            naming: {
+                column: snakeCase,
+                table: snakeCase,
+            },
+        };
+        const result = normalizeConfig(config);
+        expect(result.schema).toBe("custom");
+        expect(result.operators).toBe(config.operators);
+        expect(result.extensions).toEqual(["uuid-ossp"]);
+        expect(result.connection).toBe(config.connection);
+        expect(result.pool).toBe(true);
+        expect(result.logger).toBe(customLogger);
+        expect(result.naming.column).toBe(snakeCase);
+        expect(result.naming.table).toBe(snakeCase);
+    });
+    test("normalizes models with relationships", () => {
+        const config = {
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text", unique: true },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "post",
+                            fromField: "id",
+                            toField: "authorId",
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        authorId: { type: "integer" },
+                    },
+                },
+            },
+        };
+        const result = normalizeConfig(config);
+        expect(result.models["user"].relations["posts"]).toEqual({
+            name: "posts",
+            type: "1:N",
+            model: "post",
+            table: "post",
+            from: {
+                fields: ["id"],
+                columns: ["id"],
+            },
+            to: {
+                fields: ["authorId"],
+                columns: ["authorId"],
+            },
+        });
+    });
+    test("applies naming functions to all models", () => {
+        const config = {
+            naming: {
+                column: snakeCase,
+                table: snakeCase,
+            },
+            models: {
+                userProfile: {
+                    fields: {
+                        userId: { type: "serial", primaryKey: true },
+                        firstName: { type: "text" },
+                        lastName: { type: "text" },
+                    },
+                },
+                orderItem: {
+                    fields: {
+                        orderId: { type: "integer" },
+                        productId: { type: "integer" },
+                        unitPrice: { type: "numeric" },
+                    },
+                },
+            },
+        };
+        const result = normalizeConfig(config);
+        // Check table names
+        expect(result.models["userProfile"].table).toBe("user_profile");
+        expect(result.models["orderItem"].table).toBe("order_item");
+        // Check column names in first model
+        expect(result.models["userProfile"].fields["userId"].column).toBe("user_id");
+        expect(result.models["userProfile"].fields["firstName"].column).toBe("first_name");
+        expect(result.models["userProfile"].fields["lastName"].column).toBe("last_name");
+        // Check column names in second model
+        expect(result.models["orderItem"].fields["orderId"].column).toBe("order_id");
+        expect(result.models["orderItem"].fields["productId"].column).toBe("product_id");
+        expect(result.models["orderItem"].fields["unitPrice"].column).toBe("unit_price");
+    });
+    test("normalizes custom Zod schemas in models", () => {
+        const config = {
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: {
+                            type: "text",
+                            zodSchema: z.string().email(),
+                        },
+                        age: {
+                            type: "integer",
+                            zodSchema: z.number().min(0).max(150),
+                        },
+                    },
+                },
+            },
+        };
+        const result = normalizeConfig(config);
+        // Verify that Zod schemas are preserved
+        expect(result.models["user"].fields["email"].zodSchema).toBeInstanceOf(z.ZodString);
+        expect(result.models["user"].fields["age"].zodSchema).toBeInstanceOf(z.ZodNumber);
+    });
+    test("handles partial naming configuration", () => {
+        const config = {
+            naming: {
+                column: snakeCase,
+                // table naming function omitted
+            },
+            models: {
+                userProfile: {
+                    fields: {
+                        userId: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        };
+        const result = normalizeConfig(config);
+        // Column should be transformed
+        expect(result.models["userProfile"].fields["userId"].column).toBe("user_id");
+        // Table should remain unchanged due to default identity function
+        expect(result.models["userProfile"].table).toBe("userProfile");
+    });
+    test("handles empty extensions array", () => {
+        const config = {
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+            extensions: [],
+        };
+        const result = normalizeConfig(config);
+        expect(result.extensions).toEqual([]);
+    });
+});

package/build/normalize/normalizeField.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedFieldDefinition } from "#types/NormalizedFieldDefinition.js";
+import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
+export declare const normalizeField: (field: PopulatedFieldDefinition) => NormalizedFieldDefinition;

package/build/normalize/normalizeField.js

@@ -0,0 +1,11 @@
+export const normalizeField = (field) => {
+    return {
+        name: field.name,
+        column: field.column,
+        type: field.type,
+        zodSchema: field.zodSchema,
+        nullable: field.nullable,
+        default: field.default,
+        provided: field.provided,
+    };
+};

package/build/normalize/normalizeField.test.d.ts

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