@casekit/orm2-config 0.0.0-20250331202540 → 0.0.1

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

@@ -1,7 +1,9 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
-import { ZodSchema } from "zod";
+import { ZodType } from "zod";
+
 import { populateModels } from "./populateModels.js";
+
 describe("populateModels", () => {
     test("populates basic models with defaults", () => {
         const result = populateModels({
@@ -14,6 +16,7 @@ describe("populateModels", () => {
                 },
             },
         });
+
         expect(result).toEqual({
             user: {
                 name: "user",
@@ -28,7 +31,7 @@ describe("populateModels", () => {
                         name: "id",
                         column: "id",
                         type: "serial",
-                        zodSchema: expect.any(ZodSchema),
+                        zodSchema: expect.any(ZodType),
                         default: null,
                         references: null,
                         nullable: false,
@@ -40,7 +43,7 @@ describe("populateModels", () => {
                         name: "name",
                         column: "name",
                         type: "text",
-                        zodSchema: expect.any(ZodSchema),
+                        zodSchema: expect.any(ZodType),
                         default: null,
                         references: null,
                         nullable: false,
@@ -52,6 +55,7 @@ describe("populateModels", () => {
             },
         });
     });
+
     test("uses config schema when model schema not provided", () => {
         const result = populateModels({
             schema: "custom",
@@ -63,8 +67,10 @@ 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",
@@ -77,8 +83,10 @@ 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 },
@@ -90,8 +98,10 @@ 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 },
@@ -104,8 +114,10 @@ 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: {
@@ -119,8 +131,10 @@ describe("populateModels", () => {
                 },
             },
         });
-        expect(result["post"].primaryKey).toEqual(["authorId", "slug"]);
+
+        expect(result["post"]!.primaryKey).toEqual(["authorId", "slug"]);
     });
+
     test("handles unique constraints", () => {
         const result = populateModels({
             models: {
@@ -138,13 +152,15 @@ 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: {
@@ -169,7 +185,8 @@ describe("populateModels", () => {
                 },
             },
         });
-        expect(result["post"].foreignKeys).toEqual([
+
+        expect(result["post"]!.foreignKeys).toEqual([
             {
                 fields: ["authorId"],
                 references: {
@@ -179,6 +196,7 @@ describe("populateModels", () => {
             },
         ]);
     });
+
     test("handles relations", () => {
         const result = populateModels({
             models: {
@@ -203,7 +221,8 @@ describe("populateModels", () => {
                 },
             },
         });
-        expect(result["user"].relations).toEqual({
+
+        expect(result["user"]!.relations).toEqual({
             posts: {
                 type: "1:N",
                 model: "post",
@@ -212,6 +231,7 @@ describe("populateModels", () => {
             },
         });
     });
+
     test("handles multiple models", () => {
         const result = populateModels({
             models: {
@@ -232,9 +252,10 @@ 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/{build/normalize/populateModels.js → src/normalize/populateModels.ts}

@@ -1,6 +1,13 @@
 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) => {
+
+export const populateModels = (
+    config: Config,
+): Record<string, PopulatedModelDefinition> => {
     return mapValues(config.models, (model, name) => {
         return {
             name,
@@ -10,7 +17,9 @@ export const populateModels = (config) => {
             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/types/NormalizedConfig.d.ts → src/types/NormalizedConfig.ts}

@@ -1,12 +1,19 @@
 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/NormalizedFieldDefinition.d.ts → src/types/NormalizedFieldDefinition.ts}

@@ -1,9 +1,10 @@
 import { z } from "zod";
+
 export interface NormalizedFieldDefinition {
     name: string;
     column: string;
     type: string;
-    zodSchema: z.ZodType<unknown>;
+    zodSchema: z.ZodType;
     nullable: boolean;
     default: unknown;
     provided?: boolean;

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

@@ -3,6 +3,7 @@ import { NormalizedForeignKeyDefinition } from "./NormalizedForeignKeyDefinition
 import { NormalizedPrimaryKey } from "./NormalizedPrimaryKey.js";
 import { NormalizedRelationDefinition } from "./NormalizedRelationDefinition.js";
 import { NormalizedUniqueConstraintDefinition } from "./NormalizedUniqueConstraintDefinition.js";
+
 export interface NormalizedModelDefinition {
     name: string;
     schema: string;

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

@@ -12,6 +12,7 @@ export interface NormalizedOneToManyRelationDefinition {
         columns: string[];
     };
 }
+
 export interface NormalizedManyToManyRelationDefinition {
     name: string;
     type: "N:N";
@@ -24,6 +25,7 @@ export interface NormalizedManyToManyRelationDefinition {
         toRelation: string;
     };
 }
+
 export interface NormalizedManyToOneRelationDefinition {
     name: string;
     type: "N:1";
@@ -39,4 +41,8 @@ export interface NormalizedManyToOneRelationDefinition {
         columns: string[];
     };
 }
-export type NormalizedRelationDefinition = NormalizedOneToManyRelationDefinition | NormalizedManyToManyRelationDefinition | NormalizedManyToOneRelationDefinition;
+
+export type NormalizedRelationDefinition =
+    | NormalizedOneToManyRelationDefinition
+    | NormalizedManyToManyRelationDefinition
+    | NormalizedManyToOneRelationDefinition;

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

@@ -1,4 +1,5 @@
 import { SQLStatement } from "@casekit/sql";
+
 export interface NormalizedUniqueConstraintDefinition {
     name: string;
     fields: string[];

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

@@ -1,4 +1,5 @@
 import { FieldDefinition } from "@casekit/orm2-schema";
+
 export type PopulatedFieldDefinition = Required<FieldDefinition> & {
     name: string;
 };

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

@@ -1,5 +1,7 @@
 import { ModelDefinition } from "@casekit/orm2-schema";
+
 import { PopulatedFieldDefinition } from "./PopulatedFieldDefinition.js";
+
 export type PopulatedModelDefinition = Required<ModelDefinition> & {
     name: string;
     fields: Record<string, PopulatedFieldDefinition>;

package/src/util.ts

@@ -0,0 +1,38 @@
+import { NormalizedFieldDefinition } from "./types/NormalizedFieldDefinition.js";
+import { NormalizedModelDefinition } from "./types/NormalizedModelDefinition.js";
+import { NormalizedRelationDefinition } from "./types/NormalizedRelationDefinition.js";
+
+export const getModel = (
+    models: Record<string, NormalizedModelDefinition>,
+    name: string,
+): NormalizedModelDefinition => {
+    const model = models[name];
+    if (!model) {
+        throw new Error(`Model "${name}" not found in config`);
+    }
+    return model;
+};
+
+export const getRelation = (
+    model: NormalizedModelDefinition,
+    name: string,
+): NormalizedRelationDefinition => {
+    const relation = model.relations[name];
+    if (!relation) {
+        throw new Error(
+            `Relation "${name}" not found in model "${model.name}"`,
+        );
+    }
+    return relation;
+};
+
+export const getField = (
+    model: NormalizedModelDefinition,
+    name: string,
+): NormalizedFieldDefinition => {
+    const field = model.fields[name];
+    if (!field) {
+        throw new Error(`Field "${name}" not found in model "${model.name}"`);
+    }
+    return field;
+};

package/build/index.js

@@ -1,4 +0,0 @@
-export { normalizeConfig } from "./normalize/normalizeConfig.js";
-export { normalizeModel } from "./normalize/normalizeModel.js";
-export { normalizeUniqueConstraint } from "./normalize/normalizeUniqueConstraints.js";
-export { getField, getModel, getRelation } from "./util.js";

package/build/normalize/defaultZodSchema.d.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-/**
- * WARNING!!! The schemas in this file must be kept in sync
- * with DefaultFieldType in packages/orm-schema/src/helper/DefaultFieldType.ts.
- * If you make a change here, make sure to update the
- * corresponding type.
- */
-export declare const defaultZodSchema: (type: string) => z.ZodSchema<unknown>;

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

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

package/build/normalize/getColumns.d.ts

@@ -1,2 +0,0 @@
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-export declare const getColumns: (model: PopulatedModelDefinition, fields: string[]) => string[];

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

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

package/build/normalize/normalizeConfig.d.ts

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

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

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

package/build/normalize/normalizeField.d.ts

@@ -1,3 +0,0 @@
-import { NormalizedFieldDefinition } from "#types/NormalizedFieldDefinition.js";
-import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
-export declare const normalizeField: (field: PopulatedFieldDefinition) => NormalizedFieldDefinition;

package/build/normalize/normalizeField.js

@@ -1,11 +0,0 @@
-export const normalizeField = (field) => {
-    return {
-        name: field.name,
-        column: field.column,
-        type: field.type,
-        zodSchema: field.zodSchema,
-        nullable: field.nullable,
-        default: field.default,
-        provided: field.provided,
-    };
-};

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

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

package/build/normalize/normalizeForeignKeys.d.ts

@@ -1,5 +0,0 @@
-import { ForeignKeyDefinition } from "@casekit/orm2-schema";
-import { NormalizedForeignKeyDefinition } from "#types/NormalizedForeignKeyDefinition.js";
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-export declare const normalizeForeignKeys: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition) => NormalizedForeignKeyDefinition[];
-export declare const normalizeForeignKey: (models: Record<string, PopulatedModelDefinition>, model: PopulatedModelDefinition, fk: ForeignKeyDefinition) => NormalizedForeignKeyDefinition;

package/build/normalize/normalizeForeignKeys.js

@@ -1,50 +0,0 @@
-import { isEqual } from "es-toolkit";
-import { getColumns } from "./getColumns.js";
-export const normalizeForeignKeys = (models, model) => {
-    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, model, fk) => {
-    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) => {
-    return {
-        fields: [field.name],
-        references: {
-            model: field.references.model,
-            fields: [field.references.field],
-        },
-        onUpdate: field.references.onUpdate,
-        onDelete: field.references.onDelete,
-    };
-};
-const hasReference = (field) => {
-    return !!field.references;
-};

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

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

package/build/normalize/normalizeModel.d.ts

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

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

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

package/build/normalize/normalizePrimaryKey.d.ts

@@ -1,3 +0,0 @@
-import { NormalizedPrimaryKey } from "#types/NormalizedPrimaryKey.js";
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-export declare const normalizePrimaryKey: (model: PopulatedModelDefinition) => NormalizedPrimaryKey[];

package/build/normalize/normalizePrimaryKey.js

@@ -1,18 +0,0 @@
-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

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

package/build/normalize/normalizeRelations.d.ts

@@ -1,3 +0,0 @@
-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.test.d.ts

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

package/build/normalize/normalizeUniqueConstraints.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

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

package/build/normalize/populateField.d.ts

@@ -1,3 +0,0 @@
-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/build/normalize/populateField.test.d.ts

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