@casekit/orm2-config 1.0.0 → 1.0.1

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

@@ -3,7 +3,6 @@ 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/NormalizedModelDefinition.js

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

package/build/types/NormalizedPrimaryKey.js

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

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

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

package/build/types/NormalizedRelationDefinition.js

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

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

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

package/build/types/NormalizedUniqueConstraintDefinition.js

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

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

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

package/build/types/PopulatedFieldDefinition.js

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

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

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

package/build/types/PopulatedModelDefinition.js

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

package/build/util.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedFieldDefinition } from "./types/NormalizedFieldDefinition.js";
+import { NormalizedModelDefinition } from "./types/NormalizedModelDefinition.js";
+import { NormalizedRelationDefinition } from "./types/NormalizedRelationDefinition.js";
+export declare const getModel: (models: Record<string, NormalizedModelDefinition>, name: string) => NormalizedModelDefinition;
+export declare const getRelation: (model: NormalizedModelDefinition, name: string) => NormalizedRelationDefinition;
+export declare const getField: (model: NormalizedModelDefinition, name: string) => NormalizedFieldDefinition;

package/build/util.js

@@ -0,0 +1,21 @@
+export const getModel = (models, name) => {
+    const model = models[name];
+    if (!model) {
+        throw new Error(`Model "${name}" not found in config`);
+    }
+    return model;
+};
+export const getRelation = (model, name) => {
+    const relation = model.relations[name];
+    if (!relation) {
+        throw new Error(`Relation "${name}" not found in model "${model.name}"`);
+    }
+    return relation;
+};
+export const getField = (model, name) => {
+    const field = model.fields[name];
+    if (!field) {
+        throw new Error(`Field "${name}" not found in model "${model.name}"`);
+    }
+    return field;
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@casekit/orm2-config",
   "description": "",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": "",
   "dependencies": {
     "es-toolkit": "^1.39.3",
-    "@casekit/sql": "1.0.0",
-    "@casekit/toolbox": "1.0.0",
-    "@casekit/orm2-schema": "1.0.0"
+    "@casekit/orm2-schema": "1.0.1",
+    "@casekit/sql": "1.0.1",
+    "@casekit/toolbox": "1.0.1"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
@@ -21,18 +21,18 @@
     "typescript-eslint": "^8.34.1",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@casekit/prettier-config": "1.0.0",
-    "@casekit/tsconfig": "1.0.0",
-    "@casekit/orm2-schema": "1.0.0"
+    "@casekit/tsconfig": "1.0.1",
+    "@casekit/orm2-schema": "1.0.1",
+    "@casekit/prettier-config": "1.0.1"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./build/index.js"
   },
   "files": [
-    "/src"
+    "/build"
   ],
   "imports": {
-    "#*": "./src/*"
+    "#*": "./build/*"
   },
   "keywords": [],
   "license": "ISC",

package/src/normalize/normalizeField.ts

@@ -1,16 +0,0 @@
-import { NormalizedFieldDefinition } from "#types/NormalizedFieldDefinition.js";
-import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
-
-export const normalizeField = (
-    field: PopulatedFieldDefinition,
-): NormalizedFieldDefinition => {
-    return {
-        name: field.name,
-        column: field.column,
-        type: field.type,
-        zodSchema: field.zodSchema,
-        nullable: field.nullable,
-        default: field.default,
-        provided: field.provided,
-    };
-};

package/src/normalize/normalizeForeignKeys.ts

@@ -1,89 +0,0 @@
-import { isEqual } from "es-toolkit";
-
-import { FieldDefinition, ForeignKeyDefinition } from "@casekit/orm2-schema";
-import { MarkNonNullable } from "@casekit/toolbox";
-
-import { NormalizedForeignKeyDefinition } from "#types/NormalizedForeignKeyDefinition.js";
-import { PopulatedFieldDefinition } from "#types/PopulatedFieldDefinition.js";
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-import { getColumns } from "./getColumns.js";
-
-export const normalizeForeignKeys = (
-    models: Record<string, PopulatedModelDefinition>,
-    model: PopulatedModelDefinition,
-): NormalizedForeignKeyDefinition[] => {
-    const columnLevelForeignKeys = Object.values(model.fields)
-        .filter(hasReference)
-        .map(referenceToForeignKey)
-        .map((fk) => normalizeForeignKey(models, model, fk));
-
-    const modelLevelForeignKeys = model.foreignKeys.map((fk) =>
-        normalizeForeignKey(models, model, fk),
-    );
-
-    for (const fk of columnLevelForeignKeys) {
-        if (
-            modelLevelForeignKeys.some((other) =>
-                isEqual(fk.columns, other.columns),
-            )
-        ) {
-            throw new Error(
-                `Duplicate foreign key defined in model "${model.name}"`,
-            );
-        }
-    }
-
-    return [...columnLevelForeignKeys, ...modelLevelForeignKeys];
-};
-
-export const normalizeForeignKey = (
-    models: Record<string, PopulatedModelDefinition>,
-    model: PopulatedModelDefinition,
-    fk: ForeignKeyDefinition,
-): NormalizedForeignKeyDefinition => {
-    const referencedModel = models[fk.references.model];
-    if (!referencedModel) {
-        throw new Error(
-            `Referenced model "${fk.references.model}" not found in models`,
-        );
-    }
-
-    const columns = getColumns(model, fk.fields);
-
-    return {
-        name: fk.name ?? [model.table, ...columns, "fkey"].join("_"),
-        fields: fk.fields,
-        columns: columns,
-        references: {
-            model: fk.references.model,
-            fields: fk.references.fields,
-            schema: referencedModel.schema,
-            table: referencedModel.table,
-            columns: getColumns(referencedModel, fk.references.fields),
-        },
-        onUpdate: fk.onUpdate ?? null,
-        onDelete: fk.onDelete ?? null,
-    };
-};
-
-const referenceToForeignKey = (
-    field: MarkNonNullable<PopulatedFieldDefinition, "references">,
-): ForeignKeyDefinition => {
-    return {
-        fields: [field.name],
-        references: {
-            model: field.references.model,
-            fields: [field.references.field],
-        },
-        onUpdate: field.references.onUpdate,
-        onDelete: field.references.onDelete,
-    };
-};
-
-const hasReference = (
-    field: FieldDefinition,
-): field is PopulatedFieldDefinition & {
-    references: MarkNonNullable<PopulatedFieldDefinition, "references">;
-} => {
-    return !!field.references;
-};

package/src/normalize/normalizePrimaryKey.ts

@@ -1,30 +0,0 @@
-import { NormalizedPrimaryKey } from "#types/NormalizedPrimaryKey.js";
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-
-export const normalizePrimaryKey = (
-    model: PopulatedModelDefinition,
-): NormalizedPrimaryKey[] => {
-    const fieldLevelPrimaryKey = Object.entries(model.fields)
-        .filter(([, field]) => field.primaryKey)
-        .map(([name]) => name);
-
-    if (model.primaryKey && fieldLevelPrimaryKey.length > 0) {
-        throw new Error(
-            `Model "${model.name}" has primary key fields defined at both the model and field levels.`,
-        );
-    }
-
-    const fields = model.primaryKey ?? fieldLevelPrimaryKey;
-
-    return fields.map((name) => {
-        if (!model.fields[name]) {
-            throw new Error(
-                `Primary key field "${name}" does not exist in model "${model.name}".`,
-            );
-        }
-        return {
-            field: name,
-            column: model.fields[name].column,
-        };
-    });
-};

package/src/normalize/normalizeUniqueConstraints.ts

@@ -1,58 +0,0 @@
-import { UniqueConstraintDefinition } from "@casekit/orm2-schema";
-
-import { NormalizedUniqueConstraintDefinition } from "#types/NormalizedUniqueConstraintDefinition.js";
-import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
-import { getColumns } from "./getColumns.js";
-
-export const normalizeUniqueConstraint = (
-    model: PopulatedModelDefinition,
-    constraint: UniqueConstraintDefinition,
-): NormalizedUniqueConstraintDefinition => {
-    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: PopulatedModelDefinition,
-): NormalizedUniqueConstraintDefinition[] => {
-    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/src/normalize/populateField.test.ts

@@ -1,253 +0,0 @@
-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/src/util.ts

@@ -1,38 +0,0 @@
-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;
-};