@casekit/orm2-config 0.0.0-20250322230249

package/build/normalize/normalizePrimaryKey.test.js

@@ -0,0 +1,144 @@
+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({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        name: { type: "text" },
+                    },
+                },
+            },
+        });
+        const result = normalizePrimaryKey(models["user"]);
+        expect(result).toEqual([
+            {
+                field: "id",
+                column: "id",
+            },
+        ]);
+    });
+    test("normalizes model-level primary key", () => {
+        const models = populateModels({
+            models: {
+                userRole: {
+                    primaryKey: ["userId", "roleId"],
+                    fields: {
+                        userId: { type: "integer" },
+                        roleId: { type: "integer" },
+                        assignedAt: { type: "timestamp" },
+                    },
+                },
+            },
+        });
+        const result = normalizePrimaryKey(models["userRole"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                column: "userId",
+            },
+            {
+                field: "roleId",
+                column: "roleId",
+            },
+        ]);
+    });
+    test("throws error when primary key is defined at both levels", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    primaryKey: ["id"],
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        name: { type: "text" },
+                    },
+                },
+            },
+        });
+        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 },
+            models: {
+                user: {
+                    fields: {
+                        userId: { type: "serial", primaryKey: true },
+                        fullName: { type: "text" },
+                    },
+                },
+            },
+        });
+        const result = normalizePrimaryKey(models["user"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                column: "user_id",
+            },
+        ]);
+    });
+    test("handles custom column names", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: {
+                            type: "serial",
+                            primaryKey: true,
+                            column: "user_identifier",
+                        },
+                    },
+                },
+            },
+        });
+        const result = normalizePrimaryKey(models["user"]);
+        expect(result).toEqual([
+            {
+                field: "id",
+                column: "user_identifier",
+            },
+        ]);
+    });
+    test("throws error for non-existent primary key field in model-level definition", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    primaryKey: ["nonexistent"],
+                    fields: {
+                        id: { type: "serial" },
+                        name: { type: "text" },
+                    },
+                },
+            },
+        });
+        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: {
+                userRole: {
+                    fields: {
+                        userId: { type: "integer", primaryKey: true },
+                        roleId: { type: "integer", primaryKey: true },
+                        assignedAt: { type: "timestamp" },
+                    },
+                },
+            },
+        });
+        const result = normalizePrimaryKey(models["userRole"]);
+        expect(result).toEqual([
+            {
+                field: "userId",
+                column: "userId",
+            },
+            {
+                field: "roleId",
+                column: "roleId",
+            },
+        ]);
+    });
+});

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/build/normalize/normalizeRelations.js

@@ -0,0 +1,58 @@
+import { mapValues } from "es-toolkit";
+import { castArray } from "es-toolkit/compat";
+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}".`);
+        }
+        return model.fields[field].column;
+    });
+    return { fields: castArray(fields), columns };
+};
+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}".`);
+        }
+        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.`);
+            }
+            return {
+                name,
+                type: relation.type,
+                model: relation.model,
+                table: relatedModel.table,
+                through: {
+                    model: joinModel.name,
+                    table: joinModel.table,
+                    fromRelation: relation.through.fromRelation,
+                    toRelation: relation.through.toRelation,
+                },
+            };
+        }
+        else if (relation.type === "1:N") {
+            return {
+                name,
+                type: relation.type,
+                model: relation.model,
+                table: relatedModel.table,
+                from: normalizeRelationKeys(model, relation.fromField),
+                to: normalizeRelationKeys(relatedModel, relation.toField),
+            };
+        }
+        else {
+            return {
+                name,
+                type: relation.type,
+                model: relation.model,
+                table: relatedModel.table,
+                optional: relation.optional ?? false,
+                from: normalizeRelationKeys(model, relation.fromField),
+                to: normalizeRelationKeys(relatedModel, relation.toField),
+            };
+        }
+    });
+};

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

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

package/build/normalize/normalizeRelations.test.js

@@ -0,0 +1,298 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { normalizeRelations } from "./normalizeRelations.js";
+import { populateModels } from "./populateModels.js";
+describe("normalizeRelations", () => {
+    test("normalizes one-to-many relation", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "post",
+                            fromField: "id",
+                            toField: "authorId",
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial" },
+                        authorId: { type: "integer" },
+                    },
+                },
+            },
+        });
+        const result = normalizeRelations(models, models["user"]);
+        expect(result).toEqual({
+            posts: {
+                name: "posts",
+                type: "1:N",
+                model: "post",
+                table: "post",
+                from: {
+                    fields: ["id"],
+                    columns: ["id"],
+                },
+                to: {
+                    fields: ["authorId"],
+                    columns: ["author_id"],
+                },
+            },
+        });
+    });
+    test("normalizes many-to-one relation", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                post: {
+                    fields: {
+                        id: { type: "serial" },
+                        authorId: { type: "integer" },
+                    },
+                    relations: {
+                        author: {
+                            type: "N:1",
+                            model: "user",
+                            fromField: "authorId",
+                            toField: "id",
+                        },
+                    },
+                },
+                user: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                },
+            },
+        });
+        const result = normalizeRelations(models, models["post"]);
+        expect(result).toEqual({
+            author: {
+                name: "author",
+                type: "N:1",
+                model: "user",
+                table: "user",
+                from: {
+                    fields: ["authorId"],
+                    columns: ["author_id"],
+                },
+                to: {
+                    fields: ["id"],
+                    columns: ["id"],
+                },
+                optional: false,
+            },
+        });
+    });
+    test("normalizes many-to-many relation", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                    relations: {
+                        likedPosts: {
+                            type: "N:N",
+                            model: "post",
+                            through: {
+                                model: "like",
+                                fromRelation: "user",
+                                toRelation: "post",
+                            },
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                },
+                like: {
+                    fields: {
+                        userId: { type: "integer" },
+                        postId: { type: "integer" },
+                    },
+                },
+            },
+        });
+        const result = normalizeRelations(models, models["user"]);
+        expect(result).toEqual({
+            likedPosts: {
+                model: "post",
+                name: "likedPosts",
+                table: "post",
+                through: {
+                    model: "like",
+                    table: "like",
+                    fromRelation: "user",
+                    toRelation: "post",
+                },
+                type: "N:N",
+            },
+        });
+    });
+    test("handles composite keys in relations", () => {
+        const models = populateModels({
+            naming: { column: snakeCase },
+            models: {
+                order: {
+                    fields: {
+                        orderId: { type: "integer" },
+                        productId: { type: "integer" },
+                        variantId: { type: "integer" },
+                        lineNumber: { type: "integer" },
+                    },
+                    relations: {
+                        product: {
+                            type: "N:1",
+                            model: "product",
+                            fromField: ["productId", "variantId"],
+                            toField: ["id", "variantId"],
+                        },
+                    },
+                },
+                product: {
+                    fields: {
+                        id: { type: "serial" },
+                        variantId: { type: "integer" },
+                    },
+                },
+            },
+        });
+        const result = normalizeRelations(models, models["order"]);
+        expect(result).toEqual({
+            product: {
+                name: "product",
+                type: "N:1",
+                model: "product",
+                table: "product",
+                from: {
+                    fields: ["productId", "variantId"],
+                    columns: ["product_id", "variant_id"],
+                },
+                to: {
+                    fields: ["id", "variantId"],
+                    columns: ["id", "variant_id"],
+                },
+                optional: false,
+            },
+        });
+    });
+    test("throws error for non-existent related model", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "nonexistent",
+                            fromField: "id",
+                            toField: "authorId",
+                        },
+                    },
+                },
+            },
+        });
+        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: {
+                user: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                    relations: {
+                        likedPosts: {
+                            type: "N:N",
+                            model: "post",
+                            through: {
+                                model: "nonexistent",
+                                fromRelation: "user",
+                                toRelation: "post",
+                            },
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                },
+            },
+        });
+        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: {
+                user: {
+                    fields: {
+                        id: { type: "serial" },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "post",
+                            fromField: "nonexistent",
+                            toField: "authorId",
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial" },
+                        authorId: { type: "integer" },
+                    },
+                },
+            },
+        });
+        expect(() => normalizeRelations(models, models["user"])).toThrow('Model "user" has relation with non-existent field "nonexistent".');
+    });
+    test("handles custom column names", () => {
+        const models = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: {
+                            type: "serial",
+                            column: "user_identifier",
+                        },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "post",
+                            fromField: "id",
+                            toField: "authorId",
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial" },
+                        authorId: {
+                            type: "integer",
+                            column: "created_by_user",
+                        },
+                    },
+                },
+            },
+        });
+        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"]);
+    });
+});

package/build/normalize/normalizeUniqueConstraints.d.ts

@@ -0,0 +1,5 @@
+import { UniqueConstraintDefinition } from "@casekit/orm2-schema";
+import { NormalizedUniqueConstraintDefinition } from "#types/NormalizedUniqueConstraintDefinition.js";
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+export declare const normalizeUniqueConstraint: (model: PopulatedModelDefinition, constraint: UniqueConstraintDefinition) => NormalizedUniqueConstraintDefinition;
+export declare const normalizeUniqueConstraints: (model: PopulatedModelDefinition) => NormalizedUniqueConstraintDefinition[];

package/build/normalize/normalizeUniqueConstraints.js

@@ -0,0 +1,29 @@
+import { getColumns } from "./getColumns.js";
+export const normalizeUniqueConstraint = (model, constraint) => {
+    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) => {
+    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/build/normalize/normalizeUniqueConstraints.test.d.ts

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