@casekit/orm2-config 0.0.0-20250322230249

package/build/normalize/normalizeUniqueConstraints.test.js

@@ -0,0 +1,241 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { sql } from "@casekit/sql";
+import { normalizeUniqueConstraints } from "./normalizeUniqueConstraints.js";
+import { populateModels } from "./populateModels.js";
+describe("normalizeUniqueConstraints", () => {
+    test("handles both column-level and model-level unique constraints", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text", unique: true },
+                        username: { type: "text" },
+                    },
+                    uniqueConstraints: [
+                        {
+                            fields: ["username"],
+                        },
+                    ],
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([
+            {
+                name: "user_email_ukey",
+                fields: ["email"],
+                columns: ["email"],
+                where: null,
+                nullsNotDistinct: false,
+            },
+            {
+                name: "user_username_ukey",
+                fields: ["username"],
+                columns: ["username"],
+                where: null,
+                nullsNotDistinct: false,
+            },
+        ]);
+    });
+    test("handles complex column-level unique constraints", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: {
+                            type: "text",
+                            unique: {
+                                where: sql `deleted_at IS NULL`,
+                                nullsNotDistinct: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([
+            {
+                name: "user_email_ukey",
+                fields: ["email"],
+                columns: ["email"],
+                where: sql `deleted_at IS NULL`,
+                nullsNotDistinct: true,
+            },
+        ]);
+    });
+    test("handles fields with unique: false", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text", unique: false },
+                    },
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([]);
+    });
+    test("handles multiple model-level unique constraints", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        firstName: { type: "text" },
+                        lastName: { type: "text" },
+                        email: { type: "text" },
+                    },
+                    uniqueConstraints: [
+                        {
+                            fields: ["firstName", "lastName"],
+                            nullsNotDistinct: true,
+                        },
+                        {
+                            name: "unique_email",
+                            fields: ["email"],
+                            where: sql `deleted_at IS NULL`,
+                        },
+                    ],
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([
+            {
+                name: "user_first_name_last_name_ukey",
+                fields: ["firstName", "lastName"],
+                columns: ["first_name", "last_name"],
+                where: null,
+                nullsNotDistinct: true,
+            },
+            {
+                name: "unique_email",
+                fields: ["email"],
+                columns: ["email"],
+                where: sql `deleted_at IS NULL`,
+                nullsNotDistinct: false,
+            },
+        ]);
+    });
+    test("handles custom column names", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: {
+                            type: "text",
+                            column: "user_email",
+                            unique: true,
+                        },
+                    },
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([
+            {
+                name: "user_user_email_ukey",
+                fields: ["email"],
+                columns: ["user_email"],
+                where: null,
+                nullsNotDistinct: false,
+            },
+        ]);
+    });
+    test("returns empty array when no unique constraints exist", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text" },
+                    },
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([]);
+    });
+    test("throws error for non-existent fields in model-level constraints", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                    uniqueConstraints: [
+                        {
+                            fields: ["nonexistent"],
+                        },
+                    ],
+                },
+            },
+        });
+        expect(() => normalizeUniqueConstraints(models["user"])).toThrow('Field "nonexistent" not found in model "user"');
+    });
+    test("handles mix of boolean and object unique constraints at column level", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text", unique: true },
+                        username: {
+                            type: "text",
+                            unique: {
+                                where: sql `active = true`,
+                                nullsNotDistinct: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const result = normalizeUniqueConstraints(models["user"]);
+        expect(result).toEqual([
+            {
+                name: "user_email_ukey",
+                fields: ["email"],
+                columns: ["email"],
+                where: null,
+                nullsNotDistinct: false,
+            },
+            {
+                name: "user_username_ukey",
+                fields: ["username"],
+                columns: ["username"],
+                where: sql `active = true`,
+                nullsNotDistinct: true,
+            },
+        ]);
+    });
+    test("throws error for duplicate unique constraints", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text", unique: true },
+                    },
+                    uniqueConstraints: [
+                        {
+                            fields: ["email"], // This duplicates the column-level unique constraint
+                        },
+                    ],
+                },
+            },
+        });
+        expect(() => normalizeUniqueConstraints(models["user"])).toThrow('Duplicate unique constraint defined in model "user"');
+    });
+});

package/build/normalize/populateField.d.ts

@@ -0,0 +1,3 @@
+import { Config, FieldDefinition } from "@casekit/orm2-schema";
+import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
+export declare const populateField: (config: Config, definition: FieldDefinition, name: string) => PopulatedFieldDefinition;

package/build/normalize/populateField.js

@@ -0,0 +1,15 @@
+import { defaultZodSchema } from "./defaultZodSchema.js";
+export const populateField = (config, definition, name) => {
+    return {
+        name,
+        column: definition.column ?? config.naming?.column?.(name) ?? name,
+        type: definition.type,
+        zodSchema: definition.zodSchema ?? defaultZodSchema(definition.type),
+        default: definition.default ?? null,
+        references: definition.references ?? null,
+        nullable: definition.nullable ?? false,
+        unique: definition.unique ?? false,
+        provided: definition.provided ?? false,
+        primaryKey: definition.primaryKey ?? false,
+    };
+};

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

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

package/build/normalize/populateField.test.js

@@ -0,0 +1,198 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { ZodSchema, z } from "zod";
+import { populateField } from "./populateField.js";
+describe("populateField", () => {
+    test("populates minimal field definition with defaults", () => {
+        const result = populateField({
+            models: {
+                user: {
+                    fields: {
+                        name: { type: "text" },
+                    },
+                },
+            },
+        }, { type: "text" }, "name");
+        expect(result).toEqual({
+            name: "name",
+            column: "name",
+            type: "text",
+            zodSchema: expect.any(ZodSchema),
+            default: null,
+            references: null,
+            nullable: false,
+            unique: false,
+            primaryKey: false,
+            provided: false,
+        });
+    });
+    test("applies naming function to column name when provided", () => {
+        const result = populateField({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        fullName: { type: "text" },
+                    },
+                },
+            },
+        }, { type: "text" }, "fullName");
+        expect(result.column).toBe("full_name");
+    });
+    test("uses explicit column name over naming function", () => {
+        const result = populateField({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        fullName: { type: "text", column: "explicit_name" },
+                    },
+                },
+            },
+        }, { type: "text", column: "explicit_name" }, "fullName");
+        expect(result.column).toBe("explicit_name");
+    });
+    test("preserves custom zodSchema", () => {
+        const customSchema = z.string().email();
+        const result = populateField({
+            models: {
+                user: {
+                    fields: {
+                        email: { type: "text", zodSchema: customSchema },
+                    },
+                },
+            },
+        }, { type: "text", zodSchema: customSchema }, "email");
+        expect(result.zodSchema).toEqual(customSchema);
+    });
+    test("preserves all provided values", () => {
+        const result = populateField({
+            models: {
+                user: {
+                    fields: {
+                        id: {
+                            type: "integer",
+                            column: "custom_id",
+                            zodSchema: z.number().min(1),
+                            default: 42,
+                            references: { model: "other", field: "id" },
+                            nullable: true,
+                            unique: true,
+                            primaryKey: true,
+                            provided: true,
+                        },
+                    },
+                },
+                other: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        }, {
+            type: "integer",
+            column: "custom_id",
+            zodSchema: z.number().min(1),
+            default: 42,
+            references: { model: "other", field: "id" },
+            nullable: true,
+            unique: true,
+            primaryKey: true,
+            provided: true,
+        }, "id");
+        expect(result).toEqual({
+            name: "id",
+            type: "integer",
+            column: "custom_id",
+            zodSchema: expect.any(ZodSchema),
+            default: 42,
+            references: { model: "other", field: "id" },
+            nullable: true,
+            unique: true,
+            primaryKey: true,
+            provided: true,
+        });
+    });
+    test("handles array types", () => {
+        const result = populateField({
+            models: {
+                post: {
+                    fields: {
+                        tags: { type: "text[]" },
+                    },
+                },
+            },
+        }, { type: "text[]" }, "tags");
+        expect(result).toEqual({
+            name: "tags",
+            column: "tags",
+            type: "text[]",
+            zodSchema: expect.any(ZodSchema),
+            default: null,
+            references: null,
+            nullable: false,
+            unique: false,
+            primaryKey: false,
+            provided: false,
+        });
+    });
+    test("handles nullable fields", () => {
+        const result = populateField({
+            models: {
+                post: {
+                    fields: {
+                        description: { type: "text", nullable: true },
+                    },
+                },
+            },
+        }, { type: "text", nullable: true }, "description");
+        expect(result.nullable).toBe(true);
+    });
+    test("handles fields with defaults", () => {
+        const result = populateField({
+            models: {
+                user: {
+                    fields: {
+                        active: { type: "boolean", default: false },
+                    },
+                },
+            },
+        }, { type: "boolean", default: false }, "active");
+        expect(result.default).toBe(false);
+    });
+    test("handles fields with foreign keys", () => {
+        const result = populateField({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        userId: {
+                            type: "integer",
+                            references: {
+                                model: "user",
+                                field: "id",
+                                onDelete: "CASCADE",
+                            },
+                        },
+                    },
+                },
+            },
+        }, {
+            type: "integer",
+            references: {
+                model: "user",
+                field: "id",
+                onDelete: "CASCADE",
+            },
+        }, "userId");
+        expect(result.references).toEqual({
+            model: "user",
+            field: "id",
+            onDelete: "CASCADE",
+        });
+    });
+});

package/build/normalize/populateModels.d.ts

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

package/build/normalize/populateModels.js

@@ -0,0 +1,16 @@
+import { mapValues } from "es-toolkit";
+import { populateField } from "./populateField.js";
+export const populateModels = (config) => {
+    return mapValues(config.models, (model, name) => {
+        return {
+            name,
+            schema: model.schema ?? config.schema ?? "public",
+            table: model.table ?? config.naming?.table?.(name) ?? name,
+            primaryKey: model.primaryKey ?? null,
+            uniqueConstraints: model.uniqueConstraints ?? [],
+            foreignKeys: model.foreignKeys ?? [],
+            relations: model.relations ?? {},
+            fields: mapValues(model.fields, (field, name) => populateField(config, field, name)),
+        };
+    });
+};

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

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