@casekit/orm2-config 1.0.0 → 1.0.2

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 {};

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

@@ -1,11 +1,8 @@
 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({
@@ -25,9 +22,7 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-
-        const result = normalizeUniqueConstraints(models["user"]!);
-
+        const result = normalizeUniqueConstraints(models["user"]);
         expect(result).toEqual([
             {
                 name: "user_email_ukey",
@@ -45,7 +40,6 @@ describe("normalizeUniqueConstraints", () => {
             },
         ]);
     });
-
     test("handles complex column-level unique constraints", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -56,7 +50,7 @@ describe("normalizeUniqueConstraints", () => {
                         email: {
                             type: "text",
                             unique: {
-                                where: sql`deleted_at IS NULL`,
+                                where: sql `deleted_at IS NULL`,
                                 nullsNotDistinct: true,
                             },
                         },
@@ -64,20 +58,17 @@ 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: {
@@ -89,12 +80,9 @@ 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 },
@@ -114,15 +102,13 @@ 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",
@@ -135,12 +121,11 @@ 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: {
@@ -156,9 +141,7 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-
-        const result = normalizeUniqueConstraints(models["user"]!);
-
+        const result = normalizeUniqueConstraints(models["user"]);
         expect(result).toEqual([
             {
                 name: "user_user_email_ukey",
@@ -169,7 +152,6 @@ describe("normalizeUniqueConstraints", () => {
             },
         ]);
     });
-
     test("returns empty array when no unique constraints exist", () => {
         const models = populateModels({
             models: {
@@ -181,12 +163,9 @@ 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: {
@@ -202,12 +181,8 @@ 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 },
@@ -219,7 +194,7 @@ describe("normalizeUniqueConstraints", () => {
                         username: {
                             type: "text",
                             unique: {
-                                where: sql`active = true`,
+                                where: sql `active = true`,
                                 nullsNotDistinct: true,
                             },
                         },
@@ -227,9 +202,7 @@ describe("normalizeUniqueConstraints", () => {
                 },
             },
         });
-
-        const result = normalizeUniqueConstraints(models["user"]!);
-
+        const result = normalizeUniqueConstraints(models["user"]);
         expect(result).toEqual([
             {
                 name: "user_email_ukey",
@@ -242,12 +215,11 @@ 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: {
@@ -264,9 +236,6 @@ 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/build/normalize/populateField.d.ts

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

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

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

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

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

package/build/normalize/populateField.test.js

@@ -0,0 +1,198 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { 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/populateModels.d.ts

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

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

@@ -1,13 +1,6 @@
 import { mapValues } from "es-toolkit";
-
-import { Config } from "@casekit/orm2-schema";
-
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
 import { populateField } from "./populateField.js";
-
-export const populateModels = (
-    config: Config,
-): Record<string, PopulatedModelDefinition> => {
+export const populateModels = (config) => {
     return mapValues(config.models, (model, name) => {
         return {
             name,
@@ -17,9 +10,7 @@ export const populateModels = (
             uniqueConstraints: model.uniqueConstraints ?? [],
             foreignKeys: model.foreignKeys ?? [],
             relations: model.relations ?? {},
-            fields: mapValues(model.fields, (field, name) =>
-                populateField(config, field, name),
-            ),
+            fields: mapValues(model.fields, (field, name) => populateField(config, field, name)),
         };
     });
 };

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

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

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

@@ -1,9 +1,7 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
 import { ZodType } from "zod";
-
 import { populateModels } from "./populateModels.js";
-
 describe("populateModels", () => {
     test("populates basic models with defaults", () => {
         const result = populateModels({
@@ -16,7 +14,6 @@ describe("populateModels", () => {
                 },
             },
         });
-
         expect(result).toEqual({
             user: {
                 name: "user",
@@ -55,7 +52,6 @@ describe("populateModels", () => {
             },
         });
     });
-
     test("uses config schema when model schema not provided", () => {
         const result = populateModels({
             schema: "custom",
@@ -67,10 +63,8 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["user"]!.schema).toBe("custom");
+        expect(result["user"].schema).toBe("custom");
     });
-
     test("model schema overrides config schema", () => {
         const result = populateModels({
             schema: "config_schema",
@@ -83,10 +77,8 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["user"]!.schema).toBe("model_schema");
+        expect(result["user"].schema).toBe("model_schema");
     });
-
     test("applies table naming function when provided", () => {
         const result = populateModels({
             naming: { table: snakeCase },
@@ -98,10 +90,8 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["userProfile"]!.table).toBe("user_profile");
+        expect(result["userProfile"].table).toBe("user_profile");
     });
-
     test("explicit table name overrides naming function", () => {
         const result = populateModels({
             naming: { table: snakeCase },
@@ -114,10 +104,8 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["userProfile"]!.table).toBe("custom_table");
+        expect(result["userProfile"].table).toBe("custom_table");
     });
-
     test("uses explicit primary key when provided", () => {
         const result = populateModels({
             models: {
@@ -131,10 +119,8 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["post"]!.primaryKey).toEqual(["authorId", "slug"]);
+        expect(result["post"].primaryKey).toEqual(["authorId", "slug"]);
     });
-
     test("handles unique constraints", () => {
         const result = populateModels({
             models: {
@@ -152,15 +138,13 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["user"]!.uniqueConstraints).toEqual([
+        expect(result["user"].uniqueConstraints).toEqual([
             {
                 name: "unique_email",
                 fields: ["email"],
             },
         ]);
     });
-
     test("handles foreign keys", () => {
         const result = populateModels({
             models: {
@@ -185,8 +169,7 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["post"]!.foreignKeys).toEqual([
+        expect(result["post"].foreignKeys).toEqual([
             {
                 fields: ["authorId"],
                 references: {
@@ -196,7 +179,6 @@ describe("populateModels", () => {
             },
         ]);
     });
-
     test("handles relations", () => {
         const result = populateModels({
             models: {
@@ -221,8 +203,7 @@ describe("populateModels", () => {
                 },
             },
         });
-
-        expect(result["user"]!.relations).toEqual({
+        expect(result["user"].relations).toEqual({
             posts: {
                 type: "1:N",
                 model: "post",
@@ -231,7 +212,6 @@ describe("populateModels", () => {
             },
         });
     });
-
     test("handles multiple models", () => {
         const result = populateModels({
             models: {
@@ -252,10 +232,9 @@ describe("populateModels", () => {
                 },
             },
         });
-
         expect(Object.keys(result)).toEqual(["user", "post", "comment"]);
-        expect(result["user"]!.name).toBe("user");
-        expect(result["post"]!.name).toBe("post");
-        expect(result["comment"]!.name).toBe("comment");
+        expect(result["user"].name).toBe("user");
+        expect(result["post"].name).toBe("post");
+        expect(result["comment"].name).toBe("comment");
     });
 });

package/{src/types/NormalizedConfig.ts → build/types/NormalizedConfig.d.ts}

@@ -1,19 +1,12 @@
 import pg from "pg";
-
 import { Logger, OperatorDefinitions } from "@casekit/orm2-schema";
-
 import { NormalizedModelDefinition } from "./NormalizedModelDefinition.js";
-
 export interface NormalizedConfig {
     readonly schema: string;
     readonly models: Record<string, NormalizedModelDefinition>;
     readonly operators: OperatorDefinitions;
     readonly extensions: readonly string[];
-    readonly connection:
-        | pg.ConnectionConfig
-        | pg.PoolConfig
-        | pg.PoolOptions
-        | null;
+    readonly connection: pg.ConnectionConfig | pg.PoolConfig | pg.PoolOptions | null;
     readonly pool: boolean;
     readonly logger: Logger;
     readonly naming: {

package/build/types/NormalizedConfig.js

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

package/{src/types/NormalizedFieldDefinition.ts → build/types/NormalizedFieldDefinition.d.ts}

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 export interface NormalizedFieldDefinition {
     name: string;
     column: string;

package/build/types/NormalizedFieldDefinition.js

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

package/build/types/NormalizedForeignKeyDefinition.js

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