@casekit/orm2-config 0.0.0-20250331202540 → 0.0.1

package/package.json

@@ -1,44 +1,44 @@
 {
   "name": "@casekit/orm2-config",
   "description": "",
-  "version": "0.0.0-20250331202540",
+  "version": "0.0.1",
   "author": "",
   "dependencies": {
-    "es-toolkit": "^1.33.0",
-    "@casekit/orm2-schema": "0.0.0-20250331202540",
-    "@casekit/sql": "0.0.0-20250331202540",
-    "@casekit/toolbox": "0.0.0-20250331202540"
+    "es-toolkit": "^1.39.3",
+    "@casekit/orm2-schema": "0.0.1",
+    "@casekit/sql": "0.0.1",
+    "@casekit/toolbox": "0.0.1"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@types/node": "^22.13.13",
-    "@types/pg": "^8.11.11",
+    "@types/node": "^24.0.3",
+    "@types/pg": "^8.15.4",
     "@types/uuid": "^10.0.0",
-    "dotenv": "^16.4.7",
+    "dotenv": "^16.5.0",
     "prettier": "^3.5.3",
-    "ts-essentials": "^10.0.4",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.28.0",
+    "ts-essentials": "^10.1.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.34.1",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.9",
-    "@casekit/tsconfig": "0.0.0-20250331202540",
-    "@casekit/prettier-config": "0.0.0-20250331202540"
+    "vitest": "^3.2.4",
+    "@casekit/tsconfig": "0.0.1",
+    "@casekit/orm2-schema": "0.0.1",
+    "@casekit/prettier-config": "0.0.1"
   },
   "exports": {
-    ".": "./build/index.js"
+    ".": "./src/index.ts"
   },
   "files": [
-    "/build"
+    "/src"
   ],
   "imports": {
-    "#*": "./build/*"
+    "#*": "./src/*"
   },
   "keywords": [],
   "license": "ISC",
-  "main": "index.js",
   "peerDependencies": {
     "pg": "^8.13.1",
-    "zod": "^3.24.2"
+    "zod": "^4.0.17"
   },
   "prettier": "@casekit/prettier-config",
   "type": "module",

package/{build/index.d.ts → src/index.ts}

@@ -6,6 +6,12 @@ export type { NormalizedFieldDefinition } from "./types/NormalizedFieldDefinitio
 export type { NormalizedForeignKeyDefinition } from "./types/NormalizedForeignKeyDefinition.js";
 export type { NormalizedModelDefinition } from "./types/NormalizedModelDefinition.js";
 export type { NormalizedPrimaryKey } from "./types/NormalizedPrimaryKey.js";
-export type { NormalizedManyToManyRelationDefinition, NormalizedManyToOneRelationDefinition, NormalizedOneToManyRelationDefinition, NormalizedRelationDefinition, } from "./types/NormalizedRelationDefinition.js";
+export type {
+    NormalizedManyToManyRelationDefinition,
+    NormalizedManyToOneRelationDefinition,
+    NormalizedOneToManyRelationDefinition,
+    NormalizedRelationDefinition,
+} from "./types/NormalizedRelationDefinition.js";
 export type { NormalizedUniqueConstraintDefinition } from "./types/NormalizedUniqueConstraintDefinition.js";
+
 export { getField, getModel, getRelation } from "./util.js";

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

@@ -1,18 +1,24 @@
 import pg from "pg";
 import { afterAll, afterEach, beforeAll, describe, expect, test } from "vitest";
+
 import { defaultZodSchema } from "./defaultZodSchema.js";
+
 describe("defaultZodSchema", () => {
-    let db;
+    let db: pg.Client;
+
     beforeAll(async () => {
         db = new pg.Client();
         await db.connect();
     });
+
     afterEach(async () => {
         await db.query("ROLLBACK");
     });
+
     afterAll(async () => {
         await db.end();
     });
+
     test.for([
         ["char", "a", "a"],
         ["character", "a", "a"],
@@ -135,18 +141,20 @@ describe("defaultZodSchema", () => {
                 ],
             ],
         ],
-    ])("%s columns", async ([datatype, value, expected = value]) => {
+    ] as const)("%s columns", async ([datatype, value, expected = value]) => {
         await db.query("BEGIN TRANSACTION");
         await db.query(`CREATE TABLE foo (value ${datatype})`);
+
         if (datatype.endsWith("serial")) {
             await db.query("INSERT INTO foo DEFAULT VALUES");
-        }
-        else {
+        } else {
             await db.query(`INSERT INTO foo (value) VALUES ($1::${datatype})`, [
                 value,
             ]);
         }
-        const result = await db.query(`SELECT * FROM foo`);
+
+        const result = await db.query<{ value: unknown }>(`SELECT * FROM foo`);
+
         const parsed = defaultZodSchema(datatype).parse(result.rows[0]?.value);
         expect(parsed).toEqual(expected);
     });

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

@@ -1,37 +1,26 @@
 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 const defaultZodSchema = (type) => {
+export const defaultZodSchema = (type: string): z.ZodType => {
     if (type.endsWith("[]"))
         return z.array(defaultZodSchema(type.slice(0, -2)));
-    if (type.startsWith("bit "))
-        return z.string();
-    if (type.startsWith("bit("))
-        return z.string();
-    if (type.startsWith("character varying"))
-        return z.string();
-    if (type.startsWith("character"))
-        return z.string();
-    if (type.startsWith("numeric "))
-        return z.string();
-    if (type.startsWith("numeric("))
-        return z.string();
-    if (type.startsWith("timestamp "))
-        return z.date();
-    if (type.startsWith("timestamp("))
-        return z.date();
-    if (type.startsWith("time "))
-        return z.string();
-    if (type.startsWith("time("))
-        return z.string();
-    if (type.startsWith("varchar "))
-        return z.string();
-    if (type.startsWith("varchar("))
-        return z.string();
+    if (type.startsWith("bit ")) return z.string();
+    if (type.startsWith("bit(")) return z.string();
+    if (type.startsWith("character varying")) return z.string();
+    if (type.startsWith("character")) return z.string();
+    if (type.startsWith("numeric ")) return z.string();
+    if (type.startsWith("numeric(")) return z.string();
+    if (type.startsWith("timestamp ")) return z.date();
+    if (type.startsWith("timestamp(")) return z.date();
+    if (type.startsWith("time ")) return z.string();
+    if (type.startsWith("time(")) return z.string();
+    if (type.startsWith("varchar ")) return z.string();
+    if (type.startsWith("varchar(")) return z.string();
     // if (type.startsWith("interval"))
     //     return z.object({
     //         years: z.number().optional(),
@@ -42,6 +31,7 @@ export const defaultZodSchema = (type) => {
     //         seconds: z.number().optional(),
     //         milliseconds: z.number().optional(),
     //     });
+
     switch (type) {
         case "bigint":
         case "bigserial":
@@ -110,9 +100,9 @@ export const defaultZodSchema = (type) => {
         //     return z.object({ x: z.number(), y: z.number() });
         case "json":
         case "jsonb":
-            return z.record(z.any());
+            return z.record(z.string(), z.any());
         case "uuid":
-            return z.string().uuid();
+            return z.uuid();
         case "boolean":
             return z.boolean();
         case "date":
@@ -120,8 +110,10 @@ export const defaultZodSchema = (type) => {
         case "timestamptz":
             return z.date();
         default:
-            throw new Error("Unsupported type: " +
-                type +
-                " - please specify a zod schema in the field definition");
+            throw new Error(
+                "Unsupported type: " +
+                    type +
+                    " - please specify a zod schema in the field definition",
+            );
     }
 };

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

@@ -1,7 +1,9 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
+
 import { getColumns } from "./getColumns.js";
 import { populateModels } from "./populateModels.js";
+
 describe("getColumns", () => {
     test("returns column names for given fields", () => {
         const models = populateModels({
@@ -16,8 +18,12 @@ describe("getColumns", () => {
                 },
             },
         });
-        expect(getColumns(models["user"], ["id", "fullName", "emailAddress"])).toEqual(["id", "full_name", "email_address"]);
+
+        expect(
+            getColumns(models["user"]!, ["id", "fullName", "emailAddress"]),
+        ).toEqual(["id", "full_name", "email_address"]);
     });
+
     test("throws error for non-existent field", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -29,8 +35,12 @@ describe("getColumns", () => {
                 },
             },
         });
-        expect(() => getColumns(models["user"], ["id", "nonexistent"])).toThrow('Field "nonexistent" not found in model "user"');
+
+        expect(() =>
+            getColumns(models["user"]!, ["id", "nonexistent"]),
+        ).toThrow('Field "nonexistent" not found in model "user"');
     });
+
     test("returns empty array for empty fields array", () => {
         const models = populateModels({
             naming: { column: snakeCase },
@@ -42,8 +52,10 @@ describe("getColumns", () => {
                 },
             },
         });
-        expect(getColumns(models["user"], [])).toEqual([]);
+
+        expect(getColumns(models["user"]!, [])).toEqual([]);
     });
+
     test("handles custom column names", () => {
         const models = populateModels({
             models: {
@@ -55,7 +67,8 @@ describe("getColumns", () => {
                 },
             },
         });
-        expect(getColumns(models["user"], ["id", "name"])).toEqual([
+
+        expect(getColumns(models["user"]!, ["id", "name"])).toEqual([
             "id",
             "user_full_name",
         ]);

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

@@ -1,4 +1,9 @@
-export const getColumns = (model, fields) => {
+import { PopulatedModelDefinition } from "#types/PopulatedModelDefinition.js";
+
+export const getColumns = (
+    model: PopulatedModelDefinition,
+    fields: string[],
+): string[] => {
     return fields.map((f) => {
         if (!model.fields[f]) {
             throw new Error(`Field "${f}" not found in model "${model.name}"`);

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

@@ -1,8 +1,11 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
 import { z } from "zod";
+
 import { sql } from "@casekit/sql";
+
 import { normalizeConfig } from "./normalizeConfig.js";
+
 describe("normalizeConfig", () => {
     test("normalizes minimal config with defaults", () => {
         const config = {
@@ -14,20 +17,24 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        };
+        } as const;
+
         const result = normalizeConfig(config);
+
         expect(result.schema).toBe("public");
         expect(result.operators).toEqual({ where: {} });
         expect(result.extensions).toEqual([]);
         expect(result.connection).toBeNull();
-        expect(result.pool).toBe(false);
+        expect(result.pool).toBe(true);
         expect(result.logger).toBe(console);
         expect(typeof result.naming.column).toBe("function");
         expect(typeof result.naming.table).toBe("function");
+
         // Test that default identity functions don't transform names
         expect(result.naming.column("userName")).toBe("userName");
         expect(result.naming.table("UserProfile")).toBe("UserProfile");
     });
+
     test("preserves provided config values", () => {
         const customLogger = {
             debug: () => {
@@ -43,7 +50,9 @@ describe("normalizeConfig", () => {
                 /* empty */
             },
         };
+
         const $contains = Symbol("contains");
+
         const config = {
             schema: "custom",
             models: {
@@ -55,7 +64,7 @@ describe("normalizeConfig", () => {
             },
             operators: {
                 where: {
-                    [$contains]: () => sql ``,
+                    [$contains]: () => sql``,
                 },
             },
             extensions: ["uuid-ossp"],
@@ -69,8 +78,10 @@ describe("normalizeConfig", () => {
                 column: snakeCase,
                 table: snakeCase,
             },
-        };
+        } as const;
+
         const result = normalizeConfig(config);
+
         expect(result.schema).toBe("custom");
         expect(result.operators).toBe(config.operators);
         expect(result.extensions).toEqual(["uuid-ossp"]);
@@ -80,6 +91,7 @@ describe("normalizeConfig", () => {
         expect(result.naming.column).toBe(snakeCase);
         expect(result.naming.table).toBe(snakeCase);
     });
+
     test("normalizes models with relationships", () => {
         const config = {
             models: {
@@ -90,7 +102,7 @@ describe("normalizeConfig", () => {
                     },
                     relations: {
                         posts: {
-                            type: "1:N",
+                            type: "1:N" as const,
                             model: "post",
                             fromField: "id",
                             toField: "authorId",
@@ -104,9 +116,11 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        };
+        } as const;
+
         const result = normalizeConfig(config);
-        expect(result.models["user"].relations["posts"]).toEqual({
+
+        expect(result.models["user"]!.relations["posts"]!).toEqual({
             name: "posts",
             type: "1:N",
             model: "post",
@@ -121,6 +135,7 @@ describe("normalizeConfig", () => {
             },
         });
     });
+
     test("applies naming functions to all models", () => {
         const config = {
             naming: {
@@ -143,20 +158,37 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        };
+        } as const;
+
         const result = normalizeConfig(config);
+
         // Check table names
-        expect(result.models["userProfile"].table).toBe("user_profile");
-        expect(result.models["orderItem"].table).toBe("order_item");
+        expect(result.models["userProfile"]!.table).toBe("user_profile");
+        expect(result.models["orderItem"]!.table).toBe("order_item");
+
         // Check column names in first model
-        expect(result.models["userProfile"].fields["userId"].column).toBe("user_id");
-        expect(result.models["userProfile"].fields["firstName"].column).toBe("first_name");
-        expect(result.models["userProfile"].fields["lastName"].column).toBe("last_name");
+        expect(result.models["userProfile"]!.fields["userId"]!.column).toBe(
+            "user_id",
+        );
+        expect(result.models["userProfile"]!.fields["firstName"]!.column).toBe(
+            "first_name",
+        );
+        expect(result.models["userProfile"]!.fields["lastName"]!.column).toBe(
+            "last_name",
+        );
+
         // Check column names in second model
-        expect(result.models["orderItem"].fields["orderId"].column).toBe("order_id");
-        expect(result.models["orderItem"].fields["productId"].column).toBe("product_id");
-        expect(result.models["orderItem"].fields["unitPrice"].column).toBe("unit_price");
+        expect(result.models["orderItem"]!.fields["orderId"]!.column).toBe(
+            "order_id",
+        );
+        expect(result.models["orderItem"]!.fields["productId"]!.column).toBe(
+            "product_id",
+        );
+        expect(result.models["orderItem"]!.fields["unitPrice"]!.column).toBe(
+            "unit_price",
+        );
     });
+
     test("normalizes custom Zod schemas in models", () => {
         const config = {
             models: {
@@ -165,7 +197,7 @@ describe("normalizeConfig", () => {
                         id: { type: "serial", primaryKey: true },
                         email: {
                             type: "text",
-                            zodSchema: z.string().email(),
+                            zodSchema: z.email(),
                         },
                         age: {
                             type: "integer",
@@ -174,12 +206,19 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        };
+        } as const;
+
         const result = normalizeConfig(config);
+
         // Verify that Zod schemas are preserved
-        expect(result.models["user"].fields["email"].zodSchema).toBeInstanceOf(z.ZodString);
-        expect(result.models["user"].fields["age"].zodSchema).toBeInstanceOf(z.ZodNumber);
+        expect(
+            result.models["user"]!.fields["email"]!.zodSchema,
+        ).toBeInstanceOf(z.ZodEmail);
+        expect(result.models["user"]!.fields["age"]!.zodSchema).toBeInstanceOf(
+            z.ZodNumber,
+        );
     });
+
     test("handles partial naming configuration", () => {
         const config = {
             naming: {
@@ -193,13 +232,18 @@ describe("normalizeConfig", () => {
                     },
                 },
             },
-        };
+        } as const;
+
         const result = normalizeConfig(config);
+
         // Column should be transformed
-        expect(result.models["userProfile"].fields["userId"].column).toBe("user_id");
+        expect(result.models["userProfile"]!.fields["userId"]!.column).toBe(
+            "user_id",
+        );
         // Table should remain unchanged due to default identity function
-        expect(result.models["userProfile"].table).toBe("userProfile");
+        expect(result.models["userProfile"]!.table).toBe("userProfile");
     });
+
     test("handles empty extensions array", () => {
         const config = {
             models: {
@@ -210,8 +254,10 @@ describe("normalizeConfig", () => {
                 },
             },
             extensions: [],
-        };
+        } as const;
+
         const result = normalizeConfig(config);
+
         expect(result.extensions).toEqual([]);
     });
 });

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

@@ -1,7 +1,12 @@
 import { identity, mapValues } from "es-toolkit";
+
+import { Config } from "@casekit/orm2-schema";
+
+import { NormalizedConfig } from "#types/NormalizedConfig.js";
 import { normalizeModel } from "./normalizeModel.js";
 import { populateModels } from "./populateModels.js";
-export const normalizeConfig = (config) => {
+
+export const normalizeConfig = (config: Config): NormalizedConfig => {
     const models = populateModels(config);
     return {
         ...config,
@@ -10,7 +15,7 @@ export const normalizeConfig = (config) => {
         operators: config.operators ?? { where: {} },
         extensions: config.extensions ?? [],
         connection: config.connection ?? null,
-        pool: config.pool ?? false,
+        pool: config.pool ?? true,
         logger: config.logger ?? console,
         naming: {
             column: config.naming?.column ?? identity,

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

@@ -1,8 +1,10 @@
 import { snakeCase } from "es-toolkit";
 import { describe, expect, test } from "vitest";
-import { ZodSchema } from "zod";
+import { ZodType } from "zod";
+
 import { normalizeField } from "./normalizeField.js";
 import { populateModels } from "./populateModels.js";
+
 describe("normalizeField", () => {
     test("strips out references, unique, and primary key properties", () => {
         const models = populateModels({
@@ -28,29 +30,32 @@ describe("normalizeField", () => {
                 },
             },
         });
-        expect(normalizeField(models["post"].fields["id"])).toEqual({
+
+        expect(normalizeField(models["post"]!.fields["id"]!)).toEqual({
             name: "id",
             column: "id",
             type: "serial",
-            zodSchema: expect.any(ZodSchema),
+            zodSchema: expect.any(ZodType),
             nullable: false,
             default: null,
             provided: false,
         });
-        expect(normalizeField(models["post"].fields["slug"])).toEqual({
+
+        expect(normalizeField(models["post"]!.fields["slug"]!)).toEqual({
             name: "slug",
             column: "slug",
             type: "text",
-            zodSchema: expect.any(ZodSchema),
+            zodSchema: expect.any(ZodType),
             nullable: false,
             default: null,
             provided: false,
         });
-        expect(normalizeField(models["post"].fields["authorId"])).toEqual({
+
+        expect(normalizeField(models["post"]!.fields["authorId"]!)).toEqual({
             name: "authorId",
             column: "author_id",
             type: "integer",
-            zodSchema: expect.any(ZodSchema),
+            zodSchema: expect.any(ZodType),
             nullable: false,
             default: null,
             provided: false,

package/src/normalize/normalizeField.ts

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