@casekit/orm2-config 0.0.0-20250331202540 → 1.0.0

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

@@ -1,7 +1,9 @@
 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({
@@ -23,7 +25,8 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+
+        expect(normalizeForeignKeys(models, models["post"]!)).toEqual([
             {
                 name: "post_user_id_fkey",
                 fields: ["userId"],
@@ -40,6 +43,7 @@ describe("normalizeForeignKeys", () => {
             },
         ]);
     });
+
     test("normalizes foreign keys defined in foreignKeys array", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -66,7 +70,8 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+
+        expect(normalizeForeignKeys(models, models["post"]!)).toEqual([
             {
                 name: "post_user_id_fkey",
                 fields: ["userId"],
@@ -83,6 +88,7 @@ describe("normalizeForeignKeys", () => {
             },
         ]);
     });
+
     test("throws error when referenced model doesn't exist", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -98,8 +104,12 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(() => normalizeForeignKeys(models, models["post"])).toThrow('Referenced model "nonexistent" not found in models');
+
+        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 },
@@ -125,7 +135,8 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+
+        expect(normalizeForeignKeys(models, models["post"]!)).toEqual([
             {
                 name: "post_user_id_fkey",
                 fields: ["userId"],
@@ -142,6 +153,7 @@ describe("normalizeForeignKeys", () => {
             },
         ]);
     });
+
     test("throws error on duplicate foreign keys", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -171,8 +183,12 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(() => normalizeForeignKeys(models, models["post"])).toThrow('Duplicate foreign key defined in model "post"');
+
+        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 },
@@ -200,7 +216,8 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+
+        expect(normalizeForeignKeys(models, models["post"]!)).toEqual([
             {
                 name: "custom_fk_name",
                 fields: ["userId"],
@@ -217,6 +234,7 @@ describe("normalizeForeignKeys", () => {
             },
         ]);
     });
+
     test("handles foreign keys in custom schema", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -238,7 +256,8 @@ describe("normalizeForeignKeys", () => {
                 },
             },
         });
-        expect(normalizeForeignKeys(models, models["post"])).toEqual([
+
+        expect(normalizeForeignKeys(models, models["post"]!)).toEqual([
             {
                 name: "post_user_id_fkey",
                 fields: ["userId"],

package/src/normalize/normalizeForeignKeys.ts

@@ -0,0 +1,89 @@
+import { isEqual } from "es-toolkit";
+
+import { FieldDefinition, ForeignKeyDefinition } from "@casekit/orm2-schema";
+import { MarkNonNullable } from "@casekit/toolbox";
+
+import { NormalizedForeignKeyDefinition } from "#types/NormalizedForeignKeyDefinition.js";
+import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+import { getColumns } from "./getColumns.js";
+
+export const normalizeForeignKeys = (
+    models: Record<string, PopulatedModelDefinition>,
+    model: PopulatedModelDefinition,
+): NormalizedForeignKeyDefinition[] => {
+    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: Record<string, PopulatedModelDefinition>,
+    model: PopulatedModelDefinition,
+    fk: ForeignKeyDefinition,
+): NormalizedForeignKeyDefinition => {
+    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: MarkNonNullable<PopulatedFieldDefinition, "references">,
+): ForeignKeyDefinition => {
+    return {
+        fields: [field.name],
+        references: {
+            model: field.references.model,
+            fields: [field.references.field],
+        },
+        onUpdate: field.references.onUpdate,
+        onDelete: field.references.onDelete,
+    };
+};
+
+const hasReference = (
+    field: FieldDefinition,
+): field is PopulatedFieldDefinition & {
+    references: MarkNonNullable<PopulatedFieldDefinition, "references">;
+} => {
+    return !!field.references;
+};

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

@@ -1,9 +1,12 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
-import { ZodSchema, z } from "zod";
+import { ZodType, 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({
@@ -19,7 +22,7 @@ describe("normalizeModel", () => {
                         email: {
                             type: "text",
                             unique: true,
-                            zodSchema: z.string().email(),
+                            zodSchema: z.email(),
                         },
                         name: {
                             type: "text",
@@ -27,7 +30,7 @@ describe("normalizeModel", () => {
                         },
                         createdAt: {
                             type: "timestamp",
-                            default: sql `NOW()`,
+                            default: sql`NOW()`,
                             provided: true,
                         },
                     },
@@ -63,32 +66,38 @@ describe("normalizeModel", () => {
                 },
             },
         });
-        const result = normalizeModel(models, models["user"]);
+
+        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({
+        expect(result.fields["id"]!).toEqual({
             name: "id",
             column: "id",
             type: "serial",
-            zodSchema: expect.any(ZodSchema),
+            zodSchema: expect.any(ZodType),
             nullable: false,
             default: null,
             provided: false,
         });
-        expect(result.fields["email"]).toEqual({
+
+        expect(result.fields["email"]!).toEqual({
             name: "email",
             column: "email",
             type: "text",
-            zodSchema: expect.any(ZodSchema),
+            zodSchema: expect.any(ZodType),
             nullable: false,
             default: null,
             provided: false,
         });
+
         // Test primary key
         expect(result.primaryKey).toEqual([{ field: "id", column: "id" }]);
+
         // Test unique constraints
         expect(result.uniqueConstraints).toEqual([
             {
@@ -99,8 +108,9 @@ describe("normalizeModel", () => {
                 nullsNotDistinct: false,
             },
         ]);
+
         // Test relations
-        expect(result.relations["posts"]).toEqual({
+        expect(result.relations["posts"]!).toEqual({
             name: "posts",
             type: "1:N",
             model: "post",
@@ -114,7 +124,8 @@ describe("normalizeModel", () => {
                 columns: ["author_id"],
             },
         });
-        expect(result.relations["likedPosts"]).toEqual({
+
+        expect(result.relations["likedPosts"]!).toEqual({
             name: "likedPosts",
             type: "N:N",
             model: "post",
@@ -127,6 +138,7 @@ describe("normalizeModel", () => {
             },
         });
     });
+
     test("normalizes model with column name transformations", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -141,12 +153,16 @@ describe("normalizeModel", () => {
                 },
             },
         });
-        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"]);
+
+        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: {
@@ -159,10 +175,13 @@ describe("normalizeModel", () => {
                 },
             },
         });
-        const result = normalizeModel(models, models["user"]);
+
+        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 },
@@ -176,12 +195,15 @@ describe("normalizeModel", () => {
                 },
             },
         });
-        const result = normalizeModel(models, models["orderLine"]);
+
+        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 },
@@ -206,7 +228,9 @@ describe("normalizeModel", () => {
                 },
             },
         });
-        const result = normalizeModel(models, models["order"]);
+
+        const result = normalizeModel(models, models["order"]!);
+
         expect(result.foreignKeys).toEqual([
             {
                 name: "order_customer_id_fkey",

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

@@ -1,10 +1,17 @@
 import { mapValues } from "es-toolkit";
+
+import { NormalizedModelDefinition } from "#types/NormalizedModelDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
 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) => {
+
+export const normalizeModel = (
+    models: Record<string, PopulatedModelDefinition>,
+    model: PopulatedModelDefinition,
+): NormalizedModelDefinition => {
     return {
         name: model.name,
         schema: model.schema,

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

@@ -1,7 +1,9 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
+
 import { normalizePrimaryKey } from "./normalizePrimaryKey.js";
 import { populateModels } from "./populateModels.js";
+
 describe("normalizePrimaryKey", () => {
     test("normalizes field-level primary key", () => {
         const models = populateModels({
@@ -14,7 +16,9 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        const result = normalizePrimaryKey(models["user"]);
+
+        const result = normalizePrimaryKey(models["user"]!);
+
         expect(result).toEqual([
             {
                 field: "id",
@@ -22,6 +26,7 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
+
     test("normalizes model-level primary key", () => {
         const models = populateModels({
             models: {
@@ -35,7 +40,9 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        const result = normalizePrimaryKey(models["userRole"]);
+
+        const result = normalizePrimaryKey(models["userRole"]!);
+
         expect(result).toEqual([
             {
                 field: "userId",
@@ -47,6 +54,7 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
+
     test("throws error when primary key is defined at both levels", () => {
         const models = populateModels({
             models: {
@@ -59,8 +67,12 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        expect(() => normalizePrimaryKey(models["user"])).toThrow('Model "user" has primary key fields defined at both the model and field levels.');
+
+        expect(() => normalizePrimaryKey(models["user"]!)).toThrow(
+            'Model "user" has primary key fields defined at both the model and field levels.',
+        );
     });
+
     test("handles column name transformations", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -73,7 +85,9 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        const result = normalizePrimaryKey(models["user"]);
+
+        const result = normalizePrimaryKey(models["user"]!);
+
         expect(result).toEqual([
             {
                 field: "userId",
@@ -81,6 +95,7 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
+
     test("handles custom column names", () => {
         const models = populateModels({
             models: {
@@ -95,7 +110,9 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        const result = normalizePrimaryKey(models["user"]);
+
+        const result = normalizePrimaryKey(models["user"]!);
+
         expect(result).toEqual([
             {
                 field: "id",
@@ -103,6 +120,7 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
+
     test("throws error for non-existent primary key field in model-level definition", () => {
         const models = populateModels({
             models: {
@@ -115,8 +133,12 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        expect(() => normalizePrimaryKey(models["user"])).toThrow('Primary key field "nonexistent" does not exist in model "user".');
+
+        expect(() => normalizePrimaryKey(models["user"]!)).toThrow(
+            'Primary key field "nonexistent" does not exist in model "user".',
+        );
     });
+
     test("handles multiple field-level primary keys", () => {
         const models = populateModels({
             models: {
@@ -129,7 +151,9 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-        const result = normalizePrimaryKey(models["userRole"]);
+
+        const result = normalizePrimaryKey(models["userRole"]!);
+
         expect(result).toEqual([
             {
                 field: "userId",

package/src/normalize/normalizePrimaryKey.ts

@@ -0,0 +1,30 @@
+import { NormalizedPrimaryKey } from "#types/NormalizedPrimaryKey.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+
+export const normalizePrimaryKey = (
+    model: PopulatedModelDefinition,
+): NormalizedPrimaryKey[] => {
+    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/normalizeRelations.test.js → src/normalize/normalizeRelations.test.ts}

@@ -1,7 +1,10 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
+
+import { NormalizedOneToManyRelationDefinition } from "../types/NormalizedRelationDefinition.js";
 import { normalizeRelations } from "./normalizeRelations.js";
 import { populateModels } from "./populateModels.js";
+
 describe("normalizeRelations", () => {
     test("normalizes one-to-many relation", () => {
         const models = populateModels({
@@ -28,7 +31,9 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        const result = normalizeRelations(models, models["user"]);
+
+        const result = normalizeRelations(models, models["user"]!);
+
         expect(result).toEqual({
             posts: {
                 name: "posts",
@@ -46,6 +51,7 @@ describe("normalizeRelations", () => {
             },
         });
     });
+
     test("normalizes many-to-one relation", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -71,7 +77,9 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        const result = normalizeRelations(models, models["post"]);
+
+        const result = normalizeRelations(models, models["post"]!);
+
         expect(result).toEqual({
             author: {
                 name: "author",
@@ -90,6 +98,7 @@ describe("normalizeRelations", () => {
             },
         });
     });
+
     test("normalizes many-to-many relation", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -123,7 +132,9 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        const result = normalizeRelations(models, models["user"]);
+
+        const result = normalizeRelations(models, models["user"]!);
+
         expect(result).toEqual({
             likedPosts: {
                 model: "post",
@@ -139,6 +150,7 @@ describe("normalizeRelations", () => {
             },
         });
     });
+
     test("handles composite keys in relations", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -167,7 +179,9 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        const result = normalizeRelations(models, models["order"]);
+
+        const result = normalizeRelations(models, models["order"]!);
+
         expect(result).toEqual({
             product: {
                 name: "product",
@@ -186,6 +200,7 @@ describe("normalizeRelations", () => {
             },
         });
     });
+
     test("throws error for non-existent related model", () => {
         const models = populateModels({
             models: {
@@ -204,8 +219,12 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        expect(() => normalizeRelations(models, models["user"])).toThrow('Model "user" has relation "posts" that references non-existent model "nonexistent".');
+
+        expect(() => normalizeRelations(models, models["user"]!)).toThrow(
+            'Model "user" has relation "posts" that references non-existent model "nonexistent".',
+        );
     });
+
     test("throws error for non-existent join model", () => {
         const models = populateModels({
             models: {
@@ -232,8 +251,12 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        expect(() => normalizeRelations(models, models["user"])).toThrow('Model "user" has relation "likedPosts" with join model "nonexistent" that does not exist.');
+
+        expect(() => normalizeRelations(models, models["user"]!)).toThrow(
+            'Model "user" has relation "likedPosts" with join model "nonexistent" that does not exist.',
+        );
     });
+
     test("throws error for non-existent field in relation", () => {
         const models = populateModels({
             models: {
@@ -258,8 +281,12 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        expect(() => normalizeRelations(models, models["user"])).toThrow('Model "user" has relation with non-existent field "nonexistent".');
+
+        expect(() => normalizeRelations(models, models["user"]!)).toThrow(
+            'Model "user" has relation with non-existent field "nonexistent".',
+        );
     });
+
     test("handles custom column names", () => {
         const models = populateModels({
             models: {
@@ -290,8 +317,10 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-        const result = normalizeRelations(models, models["user"]);
-        const posts = result["posts"];
+
+        const result = normalizeRelations(models, models["user"]!);
+
+        const posts = result["posts"]! as NormalizedOneToManyRelationDefinition;
         expect(posts.from.columns).toEqual(["user_identifier"]);
         expect(posts.to.columns).toEqual(["created_by_user"]);
     });