@casekit/orm2-config 0.0.0-20250322230249

package/build/normalize/populateModels.test.js

@@ -0,0 +1,240 @@
+import { snakeCase } from "es-toolkit";
+import { describe, expect, test } from "vitest";
+import { ZodSchema } from "zod";
+import { populateModels } from "./populateModels.js";
+describe("populateModels", () => {
+    test("populates basic models with defaults", () => {
+        const result = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        name: { type: "text" },
+                    },
+                },
+            },
+        });
+        expect(result).toEqual({
+            user: {
+                name: "user",
+                schema: "public",
+                table: "user",
+                primaryKey: null,
+                uniqueConstraints: [],
+                foreignKeys: [],
+                relations: {},
+                fields: {
+                    id: {
+                        name: "id",
+                        column: "id",
+                        type: "serial",
+                        zodSchema: expect.any(ZodSchema),
+                        default: null,
+                        references: null,
+                        nullable: false,
+                        unique: false,
+                        primaryKey: true,
+                        provided: false,
+                    },
+                    name: {
+                        name: "name",
+                        column: "name",
+                        type: "text",
+                        zodSchema: expect.any(ZodSchema),
+                        default: null,
+                        references: null,
+                        nullable: false,
+                        unique: false,
+                        primaryKey: false,
+                        provided: false,
+                    },
+                },
+            },
+        });
+    });
+    test("uses config schema when model schema not provided", () => {
+        const result = populateModels({
+            schema: "custom",
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        expect(result["user"].schema).toBe("custom");
+    });
+    test("model schema overrides config schema", () => {
+        const result = populateModels({
+            schema: "config_schema",
+            models: {
+                user: {
+                    schema: "model_schema",
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        expect(result["user"].schema).toBe("model_schema");
+    });
+    test("applies table naming function when provided", () => {
+        const result = populateModels({
+            naming: { table: snakeCase },
+            models: {
+                userProfile: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        expect(result["userProfile"].table).toBe("user_profile");
+    });
+    test("explicit table name overrides naming function", () => {
+        const result = populateModels({
+            naming: { table: snakeCase },
+            models: {
+                userProfile: {
+                    table: "custom_table",
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        expect(result["userProfile"].table).toBe("custom_table");
+    });
+    test("uses explicit primary key when provided", () => {
+        const result = populateModels({
+            models: {
+                post: {
+                    primaryKey: ["authorId", "slug"],
+                    fields: {
+                        authorId: { type: "integer" },
+                        slug: { type: "text" },
+                        content: { type: "text" },
+                    },
+                },
+            },
+        });
+        expect(result["post"].primaryKey).toEqual(["authorId", "slug"]);
+    });
+    test("handles unique constraints", () => {
+        const result = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        email: { type: "text" },
+                    },
+                    uniqueConstraints: [
+                        {
+                            name: "unique_email",
+                            fields: ["email"],
+                        },
+                    ],
+                },
+            },
+        });
+        expect(result["user"].uniqueConstraints).toEqual([
+            {
+                name: "unique_email",
+                fields: ["email"],
+            },
+        ]);
+    });
+    test("handles foreign keys", () => {
+        const result = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                    foreignKeys: [
+                        {
+                            fields: ["authorId"],
+                            references: {
+                                model: "user",
+                                fields: ["id"],
+                            },
+                        },
+                    ],
+                },
+            },
+        });
+        expect(result["post"].foreignKeys).toEqual([
+            {
+                fields: ["authorId"],
+                references: {
+                    model: "user",
+                    fields: ["id"],
+                },
+            },
+        ]);
+    });
+    test("handles relations", () => {
+        const result = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                    relations: {
+                        posts: {
+                            type: "1:N",
+                            model: "post",
+                            fromField: "id",
+                            toField: "authorId",
+                        },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                        authorId: { type: "integer" },
+                    },
+                },
+            },
+        });
+        expect(result["user"].relations).toEqual({
+            posts: {
+                type: "1:N",
+                model: "post",
+                fromField: "id",
+                toField: "authorId",
+            },
+        });
+    });
+    test("handles multiple models", () => {
+        const result = populateModels({
+            models: {
+                user: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                post: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+                comment: {
+                    fields: {
+                        id: { type: "serial", primaryKey: true },
+                    },
+                },
+            },
+        });
+        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");
+    });
+});

package/build/types/NormalizedConfig.d.ts

@@ -0,0 +1,16 @@
+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 pool: boolean;
+    readonly logger: Logger;
+    readonly naming: {
+        readonly column: (name: string) => string;
+        readonly table: (name: string) => string;
+    };
+}

package/build/types/NormalizedConfig.js

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

package/build/types/NormalizedFieldDefinition.d.ts

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

package/build/types/NormalizedFieldDefinition.js

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

package/build/types/NormalizedForeignKeyDefinition.d.ts

@@ -0,0 +1,14 @@
+export interface NormalizedForeignKeyDefinition {
+    name: string;
+    fields: string[];
+    columns: string[];
+    references: {
+        model: string;
+        fields: string[];
+        schema: string;
+        table: string;
+        columns: string[];
+    };
+    onUpdate: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | null;
+    onDelete: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | null;
+}

package/build/types/NormalizedForeignKeyDefinition.js

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

package/build/types/NormalizedModelDefinition.d.ts

@@ -0,0 +1,15 @@
+import { NormalizedFieldDefinition } from "./NormalizedFieldDefinition.js";
+import { NormalizedForeignKeyDefinition } from "./NormalizedForeignKeyDefinition.js";
+import { NormalizedPrimaryKey } from "./NormalizedPrimaryKey.js";
+import { NormalizedRelationDefinition } from "./NormalizedRelationDefinition.js";
+import { NormalizedUniqueConstraintDefinition } from "./NormalizedUniqueConstraintDefinition.js";
+export interface NormalizedModelDefinition {
+    name: string;
+    schema: string;
+    table: string;
+    primaryKey: NormalizedPrimaryKey[];
+    uniqueConstraints: NormalizedUniqueConstraintDefinition[];
+    foreignKeys: NormalizedForeignKeyDefinition[];
+    relations: Record<string, NormalizedRelationDefinition>;
+    fields: Record<string, NormalizedFieldDefinition>;
+}

package/build/types/NormalizedModelDefinition.js

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

package/build/types/NormalizedPrimaryKey.d.ts

@@ -0,0 +1,4 @@
+export type NormalizedPrimaryKey = {
+    field: string;
+    column: string;
+};

package/build/types/NormalizedPrimaryKey.js

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

package/build/types/NormalizedRelationDefinition.d.ts

@@ -0,0 +1,42 @@
+export interface NormalizedOneToManyRelationDefinition {
+    name: string;
+    type: "1:N";
+    model: string;
+    table: string;
+    from: {
+        fields: string[];
+        columns: string[];
+    };
+    to: {
+        fields: string[];
+        columns: string[];
+    };
+}
+export interface NormalizedManyToManyRelationDefinition {
+    name: string;
+    type: "N:N";
+    model: string;
+    table: string;
+    through: {
+        model: string;
+        table: string;
+        fromRelation: string;
+        toRelation: string;
+    };
+}
+export interface NormalizedManyToOneRelationDefinition {
+    name: string;
+    type: "N:1";
+    model: string;
+    table: string;
+    optional: boolean;
+    from: {
+        fields: string[];
+        columns: string[];
+    };
+    to: {
+        fields: string[];
+        columns: string[];
+    };
+}
+export type NormalizedRelationDefinition = NormalizedOneToManyRelationDefinition | NormalizedManyToManyRelationDefinition | NormalizedManyToOneRelationDefinition;

package/build/types/NormalizedRelationDefinition.js

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

package/build/types/NormalizedUniqueConstraintDefinition.d.ts

@@ -0,0 +1,8 @@
+import { SQLStatement } from "@casekit/sql";
+export interface NormalizedUniqueConstraintDefinition {
+    name: string;
+    fields: string[];
+    columns: string[];
+    where: SQLStatement | null;
+    nullsNotDistinct?: boolean;
+}

package/build/types/NormalizedUniqueConstraintDefinition.js

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

package/build/types/PopulatedFieldDefinition.d.ts

@@ -0,0 +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/build/types/PopulatedModelDefinition.d.ts

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

@@ -0,0 +1,54 @@
+{
+  "name": "@casekit/orm2-config",
+  "description": "",
+  "version": "0.0.0-20250322230249",
+  "author": "",
+  "dependencies": {
+    "es-toolkit": "^1.33.0",
+    "@casekit/orm2-schema": "0.0.0-20250322230249",
+    "@casekit/sql": "0.0.0-20250322230249",
+    "@casekit/toolbox": "0.0.0-20250322230249"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^22.13.11",
+    "@types/pg": "^8.11.11",
+    "@types/uuid": "^10.0.0",
+    "dotenv": "^16.4.7",
+    "prettier": "^3.5.3",
+    "ts-essentials": "^10.0.4",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.27.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.9",
+    "@casekit/tsconfig": "0.0.0-20250322230249",
+    "@casekit/prettier-config": "0.0.0-20250322230249"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "main": "index.js",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^3.24.2"
+  },
+  "prettier": "@casekit/prettier-config",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf ./build && tsc",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint src --max-warnings 0",
+    "test": "vitest --run --typecheck",
+    "test:watch": "vitest --typecheck",
+    "typecheck": "tsc --noEmit"
+  }
+}