@casekit/orm2-config 0.0.0-20250331181319 → 0.0.1

package/{build/normalize/normalizeRelations.js → src/normalize/normalizeRelations.ts}

@@ -1,25 +1,49 @@
 import { mapValues } from "es-toolkit";
 import { castArray } from "es-toolkit/compat";
-const normalizeRelationKeys = (model, fields) => {
+
+import {
+    NormalizedManyToManyRelationDefinition,
+    NormalizedManyToOneRelationDefinition,
+    NormalizedOneToManyRelationDefinition,
+    NormalizedRelationDefinition,
+} from "#types/NormalizedRelationDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+
+const normalizeRelationKeys = (
+    model: PopulatedModelDefinition,
+    fields: string | string[],
+) => {
     const columns = castArray(fields).map((field) => {
         if (!model.fields[field]) {
-            throw new Error(`Model "${model.name}" has relation with non-existent field "${field}".`);
+            throw new Error(
+                `Model "${model.name}" has relation with non-existent field "${field}".`,
+            );
         }
         return model.fields[field].column;
     });
     return { fields: castArray(fields), columns };
 };
-export const normalizeRelations = (models, model) => {
+
+export const normalizeRelations = (
+    models: Record<string, PopulatedModelDefinition>,
+    model: PopulatedModelDefinition,
+): Record<string, NormalizedRelationDefinition> => {
     return mapValues(model.relations, (relation, name) => {
         const relatedModel = models[relation.model];
         if (!relatedModel) {
-            throw new Error(`Model "${model.name}" has relation "${name}" that references non-existent model "${relation.model}".`);
+            throw new Error(
+                `Model "${model.name}" has relation "${name}" that references non-existent model "${relation.model}".`,
+            );
         }
+
         if (relation.type === "N:N") {
             const joinModel = models[relation.through.model];
             if (!joinModel) {
-                throw new Error(`Model "${model.name}" has relation "${name}" with join model "${relation.through.model}" that does not exist.`);
+                throw new Error(
+                    `Model "${model.name}" has relation "${name}" with join model "${relation.through.model}" that does not exist.`,
+                );
             }
+
             return {
                 name,
                 type: relation.type,
@@ -31,9 +55,8 @@ export const normalizeRelations = (models, model) => {
                     fromRelation: relation.through.fromRelation,
                     toRelation: relation.through.toRelation,
                 },
-            };
-        }
-        else if (relation.type === "1:N") {
+            } satisfies NormalizedManyToManyRelationDefinition;
+        } else if (relation.type === "1:N") {
             return {
                 name,
                 type: relation.type,
@@ -41,9 +64,8 @@ export const normalizeRelations = (models, model) => {
                 table: relatedModel.table,
                 from: normalizeRelationKeys(model, relation.fromField),
                 to: normalizeRelationKeys(relatedModel, relation.toField),
-            };
-        }
-        else {
+            } satisfies NormalizedOneToManyRelationDefinition;
+        } else {
             return {
                 name,
                 type: relation.type,
@@ -52,7 +74,7 @@ export const normalizeRelations = (models, model) => {
                 optional: relation.optional ?? false,
                 from: normalizeRelationKeys(model, relation.fromField),
                 to: normalizeRelationKeys(relatedModel, relation.toField),
-            };
+            } satisfies NormalizedManyToOneRelationDefinition;
         }
     });
 };

package/{build/normalize/normalizeUniqueConstraints.test.js → src/normalize/normalizeUniqueConstraints.test.ts}

@@ -1,8 +1,11 @@
 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({
@@ -22,7 +25,9 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([
             {
                 name: "user_email_ukey",
@@ -40,6 +45,7 @@ describe("normalizeUniqueConstraints", () => {
             },
         ]);
     });
+
     test("handles complex column-level unique constraints", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -50,7 +56,7 @@ describe("normalizeUniqueConstraints", () => {
                         email: {
                             type: "text",
                             unique: {
-                                where: sql `deleted_at IS NULL`,
+                                where: sql`deleted_at IS NULL`,
                                 nullsNotDistinct: true,
                             },
                         },
@@ -58,17 +64,20 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([
             {
                 name: "user_email_ukey",
                 fields: ["email"],
                 columns: ["email"],
-                where: sql `deleted_at IS NULL`,
+                where: sql`deleted_at IS NULL`,
                 nullsNotDistinct: true,
             },
         ]);
     });
+
     test("handles fields with unique: false", () => {
         const models = populateModels({
             models: {
@@ -80,9 +89,12 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([]);
     });
+
     test("handles multiple model-level unique constraints", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -102,13 +114,15 @@ describe("normalizeUniqueConstraints", () => {
                         {
                             name: "unique_email",
                             fields: ["email"],
-                            where: sql `deleted_at IS NULL`,
+                            where: sql`deleted_at IS NULL`,
                         },
                     ],
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([
             {
                 name: "user_first_name_last_name_ukey",
@@ -121,11 +135,12 @@ describe("normalizeUniqueConstraints", () => {
                 name: "unique_email",
                 fields: ["email"],
                 columns: ["email"],
-                where: sql `deleted_at IS NULL`,
+                where: sql`deleted_at IS NULL`,
                 nullsNotDistinct: false,
             },
         ]);
     });
+
     test("handles custom column names", () => {
         const models = populateModels({
             models: {
@@ -141,7 +156,9 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([
             {
                 name: "user_user_email_ukey",
@@ -152,6 +169,7 @@ describe("normalizeUniqueConstraints", () => {
             },
         ]);
     });
+
     test("returns empty array when no unique constraints exist", () => {
         const models = populateModels({
             models: {
@@ -163,9 +181,12 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([]);
     });
+
     test("throws error for non-existent fields in model-level constraints", () => {
         const models = populateModels({
             models: {
@@ -181,8 +202,12 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        expect(() => normalizeUniqueConstraints(models["user"])).toThrow('Field "nonexistent" not found in model "user"');
+
+        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 },
@@ -194,7 +219,7 @@ describe("normalizeUniqueConstraints", () => {
                         username: {
                             type: "text",
                             unique: {
-                                where: sql `active = true`,
+                                where: sql`active = true`,
                                 nullsNotDistinct: true,
                             },
                         },
@@ -202,7 +227,9 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        const result = normalizeUniqueConstraints(models["user"]);
+
+        const result = normalizeUniqueConstraints(models["user"]!);
+
         expect(result).toEqual([
             {
                 name: "user_email_ukey",
@@ -215,11 +242,12 @@ describe("normalizeUniqueConstraints", () => {
                 name: "user_username_ukey",
                 fields: ["username"],
                 columns: ["username"],
-                where: sql `active = true`,
+                where: sql`active = true`,
                 nullsNotDistinct: true,
             },
         ]);
     });
+
     test("throws error for duplicate unique constraints", () => {
         const models = populateModels({
             models: {
@@ -236,6 +264,9 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-        expect(() => normalizeUniqueConstraints(models["user"])).toThrow('Duplicate unique constraint defined in model "user"');
+
+        expect(() => normalizeUniqueConstraints(models["user"]!)).toThrow(
+            'Duplicate unique constraint defined in model "user"',
+        );
     });
 });

package/src/normalize/normalizeUniqueConstraints.ts

@@ -0,0 +1,58 @@
+import { UniqueConstraintDefinition } from "@casekit/orm2-schema";
+
+import { NormalizedUniqueConstraintDefinition } from "#types/NormalizedUniqueConstraintDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+import { getColumns } from "./getColumns.js";
+
+export const normalizeUniqueConstraint = (
+    model: PopulatedModelDefinition,
+    constraint: UniqueConstraintDefinition,
+): NormalizedUniqueConstraintDefinition => {
+    const columns = getColumns(model, constraint.fields);
+    return {
+        name: constraint.name ?? [model.table, ...columns, "ukey"].join("_"),
+        fields: constraint.fields,
+        columns,
+        where: constraint.where ?? null,
+        nullsNotDistinct: constraint.nullsNotDistinct ?? false,
+    };
+};
+
+export const normalizeUniqueConstraints = (
+    model: PopulatedModelDefinition,
+): NormalizedUniqueConstraintDefinition[] => {
+    const columnLevelUniqueConstraints = Object.values(model.fields)
+        .filter((field) => field.unique)
+        .map((field) =>
+            normalizeUniqueConstraint(
+                model,
+                typeof field.unique === "boolean"
+                    ? {
+                          fields: [field.name],
+                          where: null,
+                          nullsNotDistinct: false,
+                      }
+                    : { fields: [field.name], ...field.unique },
+            ),
+        );
+
+    const modelLevelUniqueConstraints = model.uniqueConstraints.map(
+        (constraint) => normalizeUniqueConstraint(model, constraint),
+    );
+
+    for (const constraint of columnLevelUniqueConstraints) {
+        if (
+            modelLevelUniqueConstraints.some((other) =>
+                constraint.fields.every((field) =>
+                    other.fields.includes(field),
+                ),
+            )
+        ) {
+            throw new Error(
+                `Duplicate unique constraint defined in model "${model.name}"`,
+            );
+        }
+    }
+
+    return [...columnLevelUniqueConstraints, ...modelLevelUniqueConstraints];
+};

package/src/normalize/populateField.test.ts

@@ -0,0 +1,253 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { ZodType, 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(ZodType),
+            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.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(ZodType),
+            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(ZodType),
+            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/populateField.js → src/normalize/populateField.ts}

@@ -1,5 +1,13 @@
+import { Config, FieldDefinition } from "@casekit/orm2-schema";
+
+import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
 import { defaultZodSchema } from "./defaultZodSchema.js";
-export const populateField = (config, definition, name) => {
+
+export const populateField = (
+    config: Config,
+    definition: FieldDefinition,
+    name: string,
+): PopulatedFieldDefinition => {
     return {
         name,
         column: definition.column ?? config.naming?.column?.(name) ?? name,