@casekit/orm2-config 1.0.0 → 1.0.2

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

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

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/{src/normalize/normalizeModel.ts → build/normalize/normalizeModel.js}

@@ -1,17 +1,10 @@
 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: Record<string, PopulatedModelDefinition>,
-    model: PopulatedModelDefinition,
-): NormalizedModelDefinition => {
+export const normalizeModel = (models, model) => {
     return {
         name: model.name,
         schema: model.schema,

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

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

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

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

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

@@ -1,9 +1,7 @@
 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({
@@ -16,9 +14,7 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-
-        const result = normalizePrimaryKey(models["user"]!);
-
+        const result = normalizePrimaryKey(models["user"]);
         expect(result).toEqual([
             {
                 field: "id",
@@ -26,7 +22,6 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
-
     test("normalizes model-level primary key", () => {
         const models = populateModels({
             models: {
@@ -40,9 +35,7 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-
-        const result = normalizePrimaryKey(models["userRole"]!);
-
+        const result = normalizePrimaryKey(models["userRole"]);
         expect(result).toEqual([
             {
                 field: "userId",
@@ -54,7 +47,6 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
-
     test("throws error when primary key is defined at both levels", () => {
         const models = populateModels({
             models: {
@@ -67,12 +59,8 @@ 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 },
@@ -85,9 +73,7 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-
-        const result = normalizePrimaryKey(models["user"]!);
-
+        const result = normalizePrimaryKey(models["user"]);
         expect(result).toEqual([
             {
                 field: "userId",
@@ -95,7 +81,6 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
-
     test("handles custom column names", () => {
         const models = populateModels({
             models: {
@@ -110,9 +95,7 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-
-        const result = normalizePrimaryKey(models["user"]!);
-
+        const result = normalizePrimaryKey(models["user"]);
         expect(result).toEqual([
             {
                 field: "id",
@@ -120,7 +103,6 @@ describe("normalizePrimaryKey", () => {
             },
         ]);
     });
-
     test("throws error for non-existent primary key field in model-level definition", () => {
         const models = populateModels({
             models: {
@@ -133,12 +115,8 @@ 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: {
@@ -151,9 +129,7 @@ describe("normalizePrimaryKey", () => {
                 },
             },
         });
-
-        const result = normalizePrimaryKey(models["userRole"]!);
-
+        const result = normalizePrimaryKey(models["userRole"]);
         expect(result).toEqual([
             {
                 field: "userId",

package/build/normalize/normalizeRelations.d.ts

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

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

@@ -1,49 +1,25 @@
 import { mapValues } from "es-toolkit";
 import { castArray } from "es-toolkit/compat";
-
-import {
-    NormalizedManyToManyRelationDefinition,
-    NormalizedManyToOneRelationDefinition,
-    NormalizedOneToManyRelationDefinition,
-    NormalizedRelationDefinition,
-} from "#types/NormalizedRelationDefinition.js";
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-
-const normalizeRelationKeys = (
-    model: PopulatedModelDefinition,
-    fields: string | string[],
-) => {
+const normalizeRelationKeys = (model, fields) => {
     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: Record<string, PopulatedModelDefinition>,
-    model: PopulatedModelDefinition,
-): Record<string, NormalizedRelationDefinition> => {
+export const normalizeRelations = (models, model) => {
     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,
@@ -55,8 +31,9 @@ export const normalizeRelations = (
                     fromRelation: relation.through.fromRelation,
                     toRelation: relation.through.toRelation,
                 },
-            } satisfies NormalizedManyToManyRelationDefinition;
-        } else if (relation.type === "1:N") {
+            };
+        }
+        else if (relation.type === "1:N") {
             return {
                 name,
                 type: relation.type,
@@ -64,8 +41,9 @@ export const normalizeRelations = (
                 table: relatedModel.table,
                 from: normalizeRelationKeys(model, relation.fromField),
                 to: normalizeRelationKeys(relatedModel, relation.toField),
-            } satisfies NormalizedOneToManyRelationDefinition;
-        } else {
+            };
+        }
+        else {
             return {
                 name,
                 type: relation.type,
@@ -74,7 +52,7 @@ export const normalizeRelations = (
                 optional: relation.optional ?? false,
                 from: normalizeRelationKeys(model, relation.fromField),
                 to: normalizeRelationKeys(relatedModel, relation.toField),
-            } satisfies NormalizedManyToOneRelationDefinition;
+            };
         }
     });
 };

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

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

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

@@ -1,10 +1,7 @@
 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({
@@ -31,9 +28,7 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-
-        const result = normalizeRelations(models, models["user"]!);
-
+        const result = normalizeRelations(models, models["user"]);
         expect(result).toEqual({
             posts: {
                 name: "posts",
@@ -51,7 +46,6 @@ describe("normalizeRelations", () => {
             },
         });
     });
-
     test("normalizes many-to-one relation", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -77,9 +71,7 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-
-        const result = normalizeRelations(models, models["post"]!);
-
+        const result = normalizeRelations(models, models["post"]);
         expect(result).toEqual({
             author: {
                 name: "author",
@@ -98,7 +90,6 @@ describe("normalizeRelations", () => {
             },
         });
     });
-
     test("normalizes many-to-many relation", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -132,9 +123,7 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-
-        const result = normalizeRelations(models, models["user"]!);
-
+        const result = normalizeRelations(models, models["user"]);
         expect(result).toEqual({
             likedPosts: {
                 model: "post",
@@ -150,7 +139,6 @@ describe("normalizeRelations", () => {
             },
         });
     });
-
     test("handles composite keys in relations", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -179,9 +167,7 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-
-        const result = normalizeRelations(models, models["order"]!);
-
+        const result = normalizeRelations(models, models["order"]);
         expect(result).toEqual({
             product: {
                 name: "product",
@@ -200,7 +186,6 @@ describe("normalizeRelations", () => {
             },
         });
     });
-
     test("throws error for non-existent related model", () => {
         const models = populateModels({
             models: {
@@ -219,12 +204,8 @@ 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: {
@@ -251,12 +232,8 @@ 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: {
@@ -281,12 +258,8 @@ 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: {
@@ -317,10 +290,8 @@ describe("normalizeRelations", () => {
                 },
             },
         });
-
-        const result = normalizeRelations(models, models["user"]!);
-
-        const posts = result["posts"]! as NormalizedOneToManyRelationDefinition;
+        const result = normalizeRelations(models, models["user"]);
+        const posts = result["posts"];
         expect(posts.from.columns).toEqual(["user_identifier"]);
         expect(posts.to.columns).toEqual(["created_by_user"]);
     });