@casekit/orm2-config 0.0.0-20250322230249

package/build/normalize/normalizeField.test.js

@@ -0,0 +1,59 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { ZodSchema } from "zod";
+import { normalizeField } from "./normalizeField.js";
+import { populateModels } from "./populateModels.js";
+describe("normalizeField", () => {
+    test("strips out references, unique, and primary key properties", () => {
+        const models = populateModels({
+            naming: {
+                column: snakeCase,
+            },
+            models: {
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        slug: {
+                            type: "text",
+                            unique: true,
+                        },
+                        authorId: {
+                            type: "integer",
+                            references: {
+                                model: "user",
+                                field: "id",
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        expect(normalizeField(models["post"].fields["id"])).toEqual({
+            name: "id",
+            column: "id",
+            type: "serial",
+            zodSchema: expect.any(ZodSchema),
+            nullable: false,
+            default: null,
+            provided: false,
+        });
+        expect(normalizeField(models["post"].fields["slug"])).toEqual({
+            name: "slug",
+            column: "slug",
+            type: "text",
+            zodSchema: expect.any(ZodSchema),
+            nullable: false,
+            default: null,
+            provided: false,
+        });
+        expect(normalizeField(models["post"].fields["authorId"])).toEqual({
+            name: "authorId",
+            column: "author_id",
+            type: "integer",
+            zodSchema: expect.any(ZodSchema),
+            nullable: false,
+            default: null,
+            provided: false,
+        });
+    });
+});

package/build/normalize/normalizeForeignKeys.d.ts

@@ -0,0 +1,5 @@
+import { ForeignKeyDefinition } from "@casekit/orm2-schema";
+import { NormalizedForeignKeyDefinition } from "#types/NormalizedForeignKeyDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+export declare const normalizeForeignKeys: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition) => NormalizedForeignKeyDefinition[];
+export declare const normalizeForeignKey: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition, fk: ForeignKeyDefinition) => NormalizedForeignKeyDefinition;

package/build/normalize/normalizeForeignKeys.js

@@ -0,0 +1,50 @@
+import { isEqual } from "es-toolkit";
+import { getColumns } from "./getColumns.js";
+export const normalizeForeignKeys = (models, model) => {
+    const columnLevelForeignKeys = Object.values(model.fields)
+        .filter(hasReference)
+        .map(referenceToForeignKey)
+        .map((fk) => normalizeForeignKey(models, model, fk));
+    const modelLevelForeignKeys = model.foreignKeys.map((fk) => normalizeForeignKey(models, model, fk));
+    for (const fk of columnLevelForeignKeys) {
+        if (modelLevelForeignKeys.some((other) => isEqual(fk.columns, other.columns))) {
+            throw new Error(`Duplicate foreign key defined in model "${model.name}"`);
+        }
+    }
+    return [...columnLevelForeignKeys, ...modelLevelForeignKeys];
+};
+export const normalizeForeignKey = (models, model, fk) => {
+    const referencedModel = models[fk.references.model];
+    if (!referencedModel) {
+        throw new Error(`Referenced model "${fk.references.model}" not found in models`);
+    }
+    const columns = getColumns(model, fk.fields);
+    return {
+        name: fk.name ?? [model.table, ...columns, "fkey"].join("_"),
+        fields: fk.fields,
+        columns: columns,
+        references: {
+            model: fk.references.model,
+            fields: fk.references.fields,
+            schema: referencedModel.schema,
+            table: referencedModel.table,
+            columns: getColumns(referencedModel, fk.references.fields),
+        },
+        onUpdate: fk.onUpdate ?? null,
+        onDelete: fk.onDelete ?? null,
+    };
+};
+const referenceToForeignKey = (field) => {
+    return {
+        fields: [field.name],
+        references: {
+            model: field.references.model,
+            fields: [field.references.field],
+        },
+        onUpdate: field.references.onUpdate,
+        onDelete: field.references.onDelete,
+    };
+};
+const hasReference = (field) => {
+    return !!field.references;
+};

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

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

package/build/normalize/normalizeForeignKeys.test.js

@@ -0,0 +1,258 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { normalizeForeignKeys } from "./normalizeForeignKeys.js";
+import { populateModels } from "./populateModels.js";
+describe("normalizeForeignKeys", () => {
+    test("normalizes foreign keys defined at the top level", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: {
+                            type: "integer",
+                            references: { model: "user", field: "id" },
+                        },
+                    },
+                },
+            },
+        });
+        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+            {
+                name: "post_user_id_fkey",
+                fields: ["userId"],
+                columns: ["user_id"],
+                references: {
+                    model: "user",
+                    fields: ["id"],
+                    schema: "public",
+                    table: "user",
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: null,
+            },
+        ]);
+    });
+    test("normalizes foreign keys defined in foreignKeys array", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: { type: "integer" },
+                    },
+                    foreignKeys: [
+                        {
+                            fields: ["userId"],
+                            references: {
+                                model: "user",
+                                fields: ["id"],
+                            },
+                        },
+                    ],
+                },
+            },
+        });
+        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+            {
+                name: "post_user_id_fkey",
+                fields: ["userId"],
+                columns: ["user_id"],
+                references: {
+                    model: "user",
+                    fields: ["id"],
+                    schema: "public",
+                    table: "user",
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: null,
+            },
+        ]);
+    });
+    test("throws error when referenced model doesn't exist", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: {
+                            type: "integer",
+                            references: { model: "nonexistent", field: "id" },
+                        },
+                    },
+                },
+            },
+        });
+        expect(() => normalizeForeignKeys(models, models["post"])).toThrow('Referenced model "nonexistent" not found in models');
+    });
+    test("respects custom onDelete and onUpdate actions", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: {
+                            type: "integer",
+                            references: {
+                                model: "user",
+                                field: "id",
+                                onDelete: "CASCADE",
+                                onUpdate: "SET NULL",
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+            {
+                name: "post_user_id_fkey",
+                fields: ["userId"],
+                columns: ["user_id"],
+                references: {
+                    model: "user",
+                    fields: ["id"],
+                    schema: "public",
+                    table: "user",
+                    columns: ["id"],
+                },
+                onUpdate: "SET NULL",
+                onDelete: "CASCADE",
+            },
+        ]);
+    });
+    test("throws error on duplicate foreign keys", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: {
+                            type: "integer",
+                            references: { model: "user", field: "id" },
+                        },
+                    },
+                    foreignKeys: [
+                        {
+                            fields: ["userId"],
+                            references: {
+                                model: "user",
+                                fields: ["id"],
+                            },
+                        },
+                    ],
+                },
+            },
+        });
+        expect(() => normalizeForeignKeys(models, models["post"])).toThrow('Duplicate foreign key defined in model "post"');
+    });
+    test("handles custom foreign key names", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: { type: "integer" },
+                    },
+                    foreignKeys: [
+                        {
+                            name: "custom_fk_name",
+                            fields: ["userId"],
+                            references: {
+                                model: "user",
+                                fields: ["id"],
+                            },
+                        },
+                    ],
+                },
+            },
+        });
+        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+            {
+                name: "custom_fk_name",
+                fields: ["userId"],
+                columns: ["user_id"],
+                references: {
+                    model: "user",
+                    fields: ["id"],
+                    schema: "public",
+                    table: "user",
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: null,
+            },
+        ]);
+    });
+    test("handles foreign keys in custom schema", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    schema: "auth",
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        userId: {
+                            type: "integer",
+                            references: { model: "user", field: "id" },
+                        },
+                    },
+                },
+            },
+        });
+        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+            {
+                name: "post_user_id_fkey",
+                fields: ["userId"],
+                columns: ["user_id"],
+                references: {
+                    model: "user",
+                    fields: ["id"],
+                    schema: "auth",
+                    table: "user",
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: null,
+            },
+        ]);
+    });
+});

package/build/normalize/normalizeModel.d.ts

@@ -0,0 +1,3 @@
+import { NormalizedModelDefinition } from "#types/NormalizedModelDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+export declare const normalizeModel: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition) => NormalizedModelDefinition;

package/build/normalize/normalizeModel.js

@@ -0,0 +1,18 @@
+import { mapValues } from "es-toolkit";
+import { normalizeField } from "./normalizeField.js";
+import { normalizeForeignKeys } from "./normalizeForeignKeys.js";
+import { normalizePrimaryKey } from "./normalizePrimaryKey.js";
+import { normalizeRelations } from "./normalizeRelations.js";
+import { normalizeUniqueConstraints } from "./normalizeUniqueConstraints.js";
+export const normalizeModel = (models, model) => {
+    return {
+        name: model.name,
+        schema: model.schema,
+        table: model.table,
+        fields: mapValues(model.fields, (field) => normalizeField(field)),
+        primaryKey: normalizePrimaryKey(model),
+        uniqueConstraints: normalizeUniqueConstraints(model),
+        foreignKeys: normalizeForeignKeys(models, model),
+        relations: normalizeRelations(models, model),
+    };
+};

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

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

package/build/normalize/normalizeModel.test.js

@@ -0,0 +1,227 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { ZodSchema, z } from "zod";
+import { sql } from "@casekit/sql";
+import { normalizeModel } from "./normalizeModel.js";
+import { populateModels } from "./populateModels.js";
+describe("normalizeModel", () => {
+    test("normalizes complete model definition", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    schema: "auth",
+                    fields: {
+                        id: {
+                            type: "serial",
+                            primaryKey: true,
+                        },
+                        email: {
+                            type: "text",
+                            unique: true,
+                            zodSchema: z.string().email(),
+                        },
+                        name: {
+                            type: "text",
+                            nullable: true,
+                        },
+                        createdAt: {
+                            type: "timestamp",
+                            default: sql `NOW()`,
+                            provided: true,
+                        },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "post",
+                            fromField: "id",
+                            toField: "authorId",
+                        },
+                        likedPosts: {
+                            type: "N:N",
+                            model: "post",
+                            through: {
+                                model: "like",
+                                fromRelation: "user",
+                                toRelation: "post",
+                            },
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        authorId: { type: "integer" },
+                    },
+                },
+                like: {
+                    fields: {
+                        userId: { type: "integer" },
+                        postId: { type: "integer" },
+                    },
+                },
+            },
+        });
+        const result = normalizeModel(models, models["user"]);
+        // Test basic model properties
+        expect(result.name).toBe("user");
+        expect(result.schema).toBe("auth");
+        expect(result.table).toBe("user");
+        // Test fields
+        expect(result.fields["id"]).toEqual({
+            name: "id",
+            column: "id",
+            type: "serial",
+            zodSchema: expect.any(ZodSchema),
+            nullable: false,
+            default: null,
+            provided: false,
+        });
+        expect(result.fields["email"]).toEqual({
+            name: "email",
+            column: "email",
+            type: "text",
+            zodSchema: expect.any(ZodSchema),
+            nullable: false,
+            default: null,
+            provided: false,
+        });
+        // Test primary key
+        expect(result.primaryKey).toEqual([{ field: "id", column: "id" }]);
+        // Test unique constraints
+        expect(result.uniqueConstraints).toEqual([
+            {
+                name: "user_email_ukey",
+                fields: ["email"],
+                columns: ["email"],
+                where: null,
+                nullsNotDistinct: false,
+            },
+        ]);
+        // Test relations
+        expect(result.relations["posts"]).toEqual({
+            name: "posts",
+            type: "1:N",
+            model: "post",
+            table: "post",
+            from: {
+                fields: ["id"],
+                columns: ["id"],
+            },
+            to: {
+                fields: ["authorId"],
+                columns: ["author_id"],
+            },
+        });
+        expect(result.relations["likedPosts"]).toEqual({
+            name: "likedPosts",
+            type: "N:N",
+            model: "post",
+            table: "post",
+            through: {
+                model: "like",
+                table: "like",
+                fromRelation: "user",
+                toRelation: "post",
+            },
+        });
+    });
+    test("normalizes model with column name transformations", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                userProfile: {
+                    fields: {
+                        userId: { type: "integer", primaryKey: true },
+                        firstName: { type: "text" },
+                        lastName: { type: "text" },
+                        emailAddress: { type: "text", unique: true },
+                    },
+                },
+            },
+        });
+        const result = normalizeModel(models, models["userProfile"]);
+        expect(result.fields["firstName"].column).toBe("first_name");
+        expect(result.fields["lastName"].column).toBe("last_name");
+        expect(result.fields["emailAddress"].column).toBe("email_address");
+        expect(result.uniqueConstraints[0].columns).toEqual(["email_address"]);
+    });
+    test("normalizes model with custom schema and table names", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    schema: "custom_schema",
+                    table: "custom_table",
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        const result = normalizeModel(models, models["user"]);
+        expect(result.schema).toBe("custom_schema");
+        expect(result.table).toBe("custom_table");
+    });
+    test("normalizes model with composite primary key", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                orderLine: {
+                    fields: {
+                        orderId: { type: "integer" },
+                        lineNumber: { type: "integer" },
+                    },
+                    primaryKey: ["orderId", "lineNumber"],
+                },
+            },
+        });
+        const result = normalizeModel(models, models["orderLine"]);
+        expect(result.primaryKey).toEqual([
+            { field: "orderId", column: "order_id" },
+            { field: "lineNumber", column: "line_number" },
+        ]);
+    });
+    test("normalizes model with foreign keys", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                order: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        customerId: {
+                            type: "integer",
+                            references: {
+                                model: "customer",
+                                field: "id",
+                                onDelete: "CASCADE",
+                            },
+                        },
+                    },
+                },
+                customer: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        const result = normalizeModel(models, models["order"]);
+        expect(result.foreignKeys).toEqual([
+            {
+                name: "order_customer_id_fkey",
+                fields: ["customerId"],
+                columns: ["customer_id"],
+                references: {
+                    model: "customer",
+                    fields: ["id"],
+                    schema: "public",
+                    table: "customer",
+                    columns: ["id"],
+                },
+                onUpdate: null,
+                onDelete: "CASCADE",
+            },
+        ]);
+    });
+});

package/build/normalize/normalizePrimaryKey.d.ts

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

package/build/normalize/normalizePrimaryKey.js

@@ -0,0 +1,18 @@
+export const normalizePrimaryKey = (model) => {
+    const fieldLevelPrimaryKey = Object.entries(model.fields)
+        .filter(([, field]) => field.primaryKey)
+        .map(([name]) => name);
+    if (model.primaryKey && fieldLevelPrimaryKey.length > 0) {
+        throw new Error(`Model "${model.name}" has primary key fields defined at both the model and field levels.`);
+    }
+    const fields = model.primaryKey ?? fieldLevelPrimaryKey;
+    return fields.map((name) => {
+        if (!model.fields[name]) {
+            throw new Error(`Primary key field "${name}" does not exist in model "${model.name}".`);
+        }
+        return {
+            field: name,
+            column: model.fields[name].column,
+        };
+    });
+};

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

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