@casekit/orm2 0.0.0-20250331181319 → 0.0.0

package/build/tests/util/db.d.ts

@@ -4,7 +4,7 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
         schema: string;
         readonly operators?: import("@casekit/orm2-schema").OperatorDefinitions;
         extensions: readonly string[];
-        readonly connection?: import("pg").ConnectionConfig | import("pg").PoolConfig | import("pg").PoolOptions | null;
+        readonly connection?: import("pg").default.ConnectionConfig | import("pg").default.PoolConfig | import("pg").default.PoolOptions | null;
         pool: boolean;
         logger: import("@casekit/orm2-schema").Logger;
         naming: {
@@ -46,10 +46,14 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                     };
                     readonly email: {
                         readonly type: "text";
+                        readonly zodSchema: import("zod").ZodEmail;
                     };
                     readonly role: {
                         readonly type: "text";
-                        readonly zodSchema: import("zod").ZodEnum<["user", "admin"]>;
+                        readonly zodSchema: import("zod").ZodEnum<{
+                            user: "user";
+                            admin: "admin";
+                        }>;
                     };
                     readonly preferences: {
                         readonly type: "jsonb";
@@ -128,30 +132,20 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                         readonly type: "jsonb";
                         readonly default: "{}";
                         readonly zodSchema: import("zod").ZodObject<{
-                            foo: import("zod").ZodEnum<["a", "b", "c"]>;
+                            foo: import("zod").ZodEnum<{
+                                a: "a";
+                                b: "b";
+                                c: "c";
+                            }>;
                             bar: import("zod").ZodArray<import("zod").ZodObject<{
-                                baz: import("zod").ZodEnum<["good", "bad", "indifferent"]>;
+                                baz: import("zod").ZodEnum<{
+                                    good: "good";
+                                    bad: "bad";
+                                    indifferent: "indifferent";
+                                }>;
                                 quux: import("zod").ZodBoolean;
-                            }, "strip", import("zod").ZodTypeAny, {
-                                baz: "good" | "bad" | "indifferent";
-                                quux: boolean;
-                            }, {
-                                baz: "good" | "bad" | "indifferent";
-                                quux: boolean;
-                            }>, "many">;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            foo: "b" | "a" | "c";
-                            bar: {
-                                baz: "good" | "bad" | "indifferent";
-                                quux: boolean;
-                            }[];
-                        }, {
-                            foo: "b" | "a" | "c";
-                            bar: {
-                                baz: "good" | "bad" | "indifferent";
-                                quux: boolean;
-                            }[];
-                        }>;
+                            }, import("zod/v4/core").$strip>>;
+                        }, import("zod/v4/core").$strip>;
                     };
                     readonly createdAt: {
                         readonly type: "timestamp";
@@ -564,10 +558,14 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                 };
                 readonly email: {
                     readonly type: "text";
+                    readonly zodSchema: import("zod").ZodEmail;
                 };
                 readonly role: {
                     readonly type: "text";
-                    readonly zodSchema: import("zod").ZodEnum<["user", "admin"]>;
+                    readonly zodSchema: import("zod").ZodEnum<{
+                        user: "user";
+                        admin: "admin";
+                    }>;
                 };
                 readonly preferences: {
                     readonly type: "jsonb";
@@ -646,30 +644,20 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                     readonly type: "jsonb";
                     readonly default: "{}";
                     readonly zodSchema: import("zod").ZodObject<{
-                        foo: import("zod").ZodEnum<["a", "b", "c"]>;
+                        foo: import("zod").ZodEnum<{
+                            a: "a";
+                            b: "b";
+                            c: "c";
+                        }>;
                         bar: import("zod").ZodArray<import("zod").ZodObject<{
-                            baz: import("zod").ZodEnum<["good", "bad", "indifferent"]>;
+                            baz: import("zod").ZodEnum<{
+                                good: "good";
+                                bad: "bad";
+                                indifferent: "indifferent";
+                            }>;
                             quux: import("zod").ZodBoolean;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }, {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }>, "many">;
-                    }, "strip", import("zod").ZodTypeAny, {
-                        foo: "b" | "a" | "c";
-                        bar: {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }[];
-                    }, {
-                        foo: "b" | "a" | "c";
-                        bar: {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }[];
-                    }>;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
                 };
                 readonly createdAt: {
                     readonly type: "timestamp";
@@ -1085,10 +1073,14 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                 };
                 readonly email: {
                     readonly type: "text";
+                    readonly zodSchema: import("zod").ZodEmail;
                 };
                 readonly role: {
                     readonly type: "text";
-                    readonly zodSchema: import("zod").ZodEnum<["user", "admin"]>;
+                    readonly zodSchema: import("zod").ZodEnum<{
+                        user: "user";
+                        admin: "admin";
+                    }>;
                 };
                 readonly preferences: {
                     readonly type: "jsonb";
@@ -1167,30 +1159,20 @@ export declare const createTestDB: (overrides?: Partial<Omit<Config, "models">>)
                     readonly type: "jsonb";
                     readonly default: "{}";
                     readonly zodSchema: import("zod").ZodObject<{
-                        foo: import("zod").ZodEnum<["a", "b", "c"]>;
+                        foo: import("zod").ZodEnum<{
+                            a: "a";
+                            b: "b";
+                            c: "c";
+                        }>;
                         bar: import("zod").ZodArray<import("zod").ZodObject<{
-                            baz: import("zod").ZodEnum<["good", "bad", "indifferent"]>;
+                            baz: import("zod").ZodEnum<{
+                                good: "good";
+                                bad: "bad";
+                                indifferent: "indifferent";
+                            }>;
                             quux: import("zod").ZodBoolean;
-                        }, "strip", import("zod").ZodTypeAny, {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }, {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }>, "many">;
-                    }, "strip", import("zod").ZodTypeAny, {
-                        foo: "b" | "a" | "c";
-                        bar: {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }[];
-                    }, {
-                        foo: "b" | "a" | "c";
-                        bar: {
-                            baz: "good" | "bad" | "indifferent";
-                            quux: boolean;
-                        }[];
-                    }>;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>;
                 };
                 readonly createdAt: {
                     readonly type: "timestamp";

package/build/types/CreateOneResult.d.ts

@@ -1,5 +1,9 @@
 import { FieldType, ModelDefinitions, ModelName } from "@casekit/orm2-schema";
 import { CreateOneParams } from "./CreateOneParams.js";
-export type CreateOneResult<Models extends ModelDefinitions, M extends ModelName<Models>, Q extends CreateOneParams<Models, M>> = Q["returning"] extends NonNullable<Q["returning"]> ? {
+export type CreateOneResult<Models extends ModelDefinitions, M extends ModelName<Models>, Q extends CreateOneParams<Models, M>> = Q["returning"] extends NonNullable<Q["returning"]> ? Q["onConflict"] extends {
+    do: "nothing";
+} ? {
     [C in Q["returning"][number]]: FieldType<Models[M], C>;
-} | null : number;
+} | null : {
+    [C in Q["returning"][number]]: FieldType<Models[M], C>;
+} : number;

package/build/types/CreateOneResult.test-d.js

@@ -20,4 +20,7 @@ describe("CreateOneResult", () => {
         // @ts-expect-error - title is not included in returning clause
         expectTypeOf().toEqualTypeOf();
     });
+    test("is nullable if onConflict is set to do nothing", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
 });

package/build/types/Middleware.d.ts

@@ -23,6 +23,7 @@ export type CreateManyMiddleware = (db: Orm, modelName: string, query: CreateMan
 export type UpdateOneMiddleware = (db: Orm, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;
 export type UpdateManyMiddleware = (db: Orm, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number | null>;
 export type Middleware = {
+    name?: string;
     where?: WhereMiddleware;
     set?: SetMiddleware;
     values?: ValuesMiddleware;
@@ -36,3 +37,16 @@ export type Middleware = {
     deleteOne?: DeleteOneMiddleware;
     deleteMany?: DeleteManyMiddleware;
 };
+type Organisation = {
+    id: string;
+};
+type User = {
+    id: string;
+};
+export declare const tenancy: ({ org }: {
+    org: Organisation;
+}) => Middleware;
+export declare const userstamps: ({ user }: {
+    user: User;
+}) => Middleware;
+export {};

package/build/types/Middleware.js

@@ -1 +1,37 @@
-export {};
+import { getModel } from "@casekit/orm2-config";
+export const tenancy = ({ org }) => ({
+    where: (config, modelName, where) => {
+        if ("organisationId" in getModel(config.models, modelName).fields) {
+            return { ...where, organisaitonId: org.id };
+        }
+        else {
+            return where;
+        }
+    },
+    values: (config, modelName, values) => {
+        if ("organisationId" in getModel(config.models, modelName).fields) {
+            return { ...values, organisationId: org.id };
+        }
+        else {
+            return values;
+        }
+    },
+});
+export const userstamps = ({ user }) => ({
+    values: (config, modelName, values) => {
+        if ("createdById" in getModel(config.models, modelName).fields) {
+            return { ...values, updatedById: values["createdById"] ?? user.id };
+        }
+        else {
+            return values;
+        }
+    },
+    set: (config, modelName, set) => {
+        if ("updatedById" in getModel(config.models, modelName).fields) {
+            return { ...set, updatedById: set["updatedById"] ?? user.id };
+        }
+        else {
+            return set;
+        }
+    },
+});

package/build/types/WhereClause.d.ts

@@ -2,22 +2,22 @@ import { DeepReadonly } from "ts-essentials";
 import { FieldName, FieldType, ModelDefinition, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
 import { $and, $eq, $gt, $gte, $ilike, $in, $is, $like, $lt, $lte, $ne, $not, $or } from "#operators.js";
 export interface DefaultOperators<T> {
-    [$eq]?: T;
-    [$ne]?: T;
+    [$eq]?: DeepReadonly<T>;
+    [$ne]?: DeepReadonly<T>;
     [$not]?: null | true | false;
     [$is]?: null | true | false;
-    [$gt]?: T;
-    [$gte]?: T;
-    [$lt]?: T;
-    [$lte]?: T;
-    [$in]?: T[];
+    [$gt]?: DeepReadonly<T>;
+    [$gte]?: DeepReadonly<T>;
+    [$lt]?: DeepReadonly<T>;
+    [$lte]?: DeepReadonly<T>;
+    [$in]?: DeepReadonly<T[]>;
     [$like]?: string;
     [$ilike]?: string;
 }
 export type ReadonlyArrays<T> = T extends (infer E)[] ? readonly E[] : T extends Date ? Date : T extends object ? {
     readonly [K in keyof T]: ReadonlyArrays<T[K]>;
 } : T;
-export type WhereClauseValue<Model extends ModelDefinition, Operators extends OperatorDefinitions, C extends FieldName<Model>, T = DeepReadonly<FieldType<Model, C>>> = T | null | DefaultOperators<T> | (Operators["where"] extends never ? never : {
+export type WhereClauseValue<Model extends ModelDefinition, Operators extends OperatorDefinitions, C extends FieldName<Model>, T = DeepReadonly<FieldType<Model, C>>> = DeepReadonly<T> | null | DefaultOperators<T> | (Operators["where"] extends never ? never : {
     [K in Extract<keyof Operators["where"], symbol>]?: Parameters<NonNullable<Operators["where"]>[K]>[1];
 });
 export type WhereClause<Models extends ModelDefinitions, Operators extends OperatorDefinitions, M extends ModelName<Models>, _Model extends ModelDefinition = Models[M]> = {

package/build/util/applySetMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinition } from "@casekit/orm2-schema";
+import { Middleware } from "../types/Middleware.js";
+import { UpdateValues } from "../types/UpdateValues.js";
+export declare const applySetMiddleware: (config: NormalizedConfig, middleware: Middleware[], modelName: string, set: UpdateValues<ModelDefinition>) => UpdateValues<ModelDefinition>;

package/build/util/applySetMiddleware.js

@@ -0,0 +1,7 @@
+export const applySetMiddleware = (config, middleware, modelName, set) => {
+    return middleware
+        .filter((m) => !!m.set)
+        .reduce((acc, m) => {
+        return m.set(config, modelName, acc);
+    }, set);
+};

package/build/util/applyValuesMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinition } from "@casekit/orm2-schema";
+import { CreateValues } from "../types/CreateValues.js";
+import { Middleware } from "../types/Middleware.js";
+export declare const applyValuesMiddleware: (config: NormalizedConfig, middleware: Middleware[], modelName: string, values: CreateValues<ModelDefinition>) => CreateValues<ModelDefinition>;

package/build/util/applyValuesMiddleware.js

@@ -0,0 +1,7 @@
+export const applyValuesMiddleware = (config, middleware, modelName, values) => {
+    return middleware
+        .filter((m) => !!m.values)
+        .reduce((acc, m) => {
+        return m.values(config, modelName, acc);
+    }, values);
+};

package/build/util/applyWhereMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NormalizedConfig } from "@casekit/orm2-config";
+import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
+import { Middleware } from "../types/Middleware.js";
+import { WhereClause } from "../types/WhereClause.js";
+export declare const applyWhereMiddleware: (config: NormalizedConfig, middleware: Middleware[], modelName: string, where: WhereClause<ModelDefinitions, OperatorDefinitions, string> | undefined) => WhereClause<ModelDefinitions, OperatorDefinitions, string> | undefined;

package/build/util/applyWhereMiddleware.js

@@ -0,0 +1,7 @@
+export const applyWhereMiddleware = (config, middleware, modelName, where) => {
+    return middleware
+        .filter((m) => !!m.where)
+        .reduce((acc, m) => {
+        return m.where(config, modelName, acc);
+    }, where ?? {});
+};

package/build/util/applyWhereMiddleware.test.d.ts

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

package/build/util/applyWhereMiddleware.test.js

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { $eq } from "#operators.js";
+import { createTestDB } from "../tests/util/db.js";
+import { mockLogger } from "../tests/util/logger.js";
+import { applyWhereMiddleware } from "./applyWhereMiddleware.js";
+describe("applyWhereMiddleware", () => {
+    const logger = mockLogger();
+    let config;
+    beforeEach(() => {
+        logger.clear();
+        const { db } = createTestDB();
+        config = db.config;
+    });
+    test("returns original where clause when no middleware exists", () => {
+        const middleware = [];
+        const modelName = "user";
+        const whereClause = { id: 1 };
+        const result = applyWhereMiddleware(config, middleware, modelName, whereClause);
+        expect(result).toBe(whereClause);
+    });
+    test("returns original where clause when middleware has no where function", () => {
+        const middleware = [{}];
+        const modelName = "user";
+        const whereClause = { id: 1 };
+        const result = applyWhereMiddleware(config, middleware, modelName, whereClause);
+        expect(result).toBe(whereClause);
+    });
+    test("applies a single middleware to the where clause", () => {
+        const modelName = "user";
+        const modifiedWhere = { id: 2 };
+        const whereMiddlewareFn = vi.fn().mockReturnValue(modifiedWhere);
+        const middleware = [
+            {
+                where: whereMiddlewareFn,
+            },
+        ];
+        const originalWhere = { id: 1 };
+        const result = applyWhereMiddleware(config, middleware, modelName, originalWhere);
+        expect(whereMiddlewareFn).toHaveBeenCalledWith(config, modelName, originalWhere);
+        expect(result).toBe(modifiedWhere);
+    });
+    test("applies multiple middleware to the where clause in order", () => {
+        const modelName = "user";
+        const middleware1Result = { id: 2 };
+        const middleware2Result = { id: 3 };
+        const whereMiddlewareFn1 = vi.fn().mockReturnValue(middleware1Result);
+        const whereMiddlewareFn2 = vi.fn().mockReturnValue(middleware2Result);
+        const middleware = [
+            {
+                where: whereMiddlewareFn1,
+            },
+            {
+                where: whereMiddlewareFn2,
+            },
+        ];
+        const originalWhere = { id: 1 };
+        const result = applyWhereMiddleware(config, middleware, modelName, originalWhere);
+        expect(whereMiddlewareFn1).toHaveBeenCalledWith(config, modelName, originalWhere);
+        expect(whereMiddlewareFn2).toHaveBeenCalledWith(config, modelName, middleware1Result);
+        expect(result).toBe(middleware2Result);
+    });
+    test("applies complex where clause with operators", () => {
+        const modelName = "user";
+        const originalWhere = {
+            name: { [$eq]: "John" },
+        };
+        const modifiedWhere = {
+            name: { [$eq]: "John" },
+            active: true,
+        };
+        const whereMiddlewareFn = vi
+            .fn()
+            .mockImplementation((config, model, where) => {
+            return {
+                ...where,
+                active: true,
+            };
+        });
+        const middleware = [
+            {
+                where: whereMiddlewareFn,
+            },
+        ];
+        const result = applyWhereMiddleware(config, middleware, modelName, originalWhere);
+        expect(whereMiddlewareFn).toHaveBeenCalledWith(config, modelName, originalWhere);
+        expect(result).toEqual(modifiedWhere);
+    });
+});

package/build/util/resultSchema.d.ts

@@ -1,10 +1,10 @@
-import { ZodSchema } from "zod";
+import { ZodType } from "zod";
 import { NormalizedConfig, NormalizedModelDefinition } from "@casekit/orm2-config";
 import { ModelDefinition, OperatorDefinitions } from "@casekit/orm2-schema";
 import { FindParams } from "../types/FindParams.js";
 import { ReturningClause } from "../types/ReturningClause.js";
-export declare const resultFields: (model: NormalizedModelDefinition, fields: string[]) => Record<string, ZodSchema<unknown>>;
-export declare const findOneResultSchema: (config: NormalizedConfig, m: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => ZodSchema<unknown>;
-export declare const findManyResultSchema: (config: NormalizedConfig, m: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => ZodSchema<unknown>;
-export declare const returningOneResultSchema: (model: NormalizedModelDefinition, fields?: string[]) => ZodSchema<unknown>;
-export declare const returningManyResultSchema: (model: NormalizedModelDefinition, returning?: ReturningClause<ModelDefinition>) => ZodSchema<unknown>;
+export declare const resultFields: (model: NormalizedModelDefinition, fields: string[]) => Record<string, ZodType>;
+export declare const findOneResultSchema: (config: NormalizedConfig, m: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => ZodType;
+export declare const findManyResultSchema: (config: NormalizedConfig, m: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => ZodType;
+export declare const returningOneResultSchema: (model: NormalizedModelDefinition, fields?: string[]) => ZodType;
+export declare const returningManyResultSchema: (model: NormalizedModelDefinition, returning?: ReturningClause<ModelDefinition>) => ZodType;

package/package.json

@@ -1,40 +1,40 @@
 {
   "name": "@casekit/orm2",
   "description": "",
-  "version": "0.0.0-20250331181319",
+  "version": "0.0.0",
   "author": "",
   "dependencies": {
-    "es-toolkit": "^1.33.0",
+    "es-toolkit": "^1.39.3",
     "object-hash": "^3.0.0",
-    "pino": "^9.6.0",
+    "pino": "^9.7.0",
     "uuid": "^11.1.0",
-    "@casekit/orm2-config": "0.0.0-20250331181319",
-    "@casekit/sql": "0.0.0-20250331181319",
-    "@casekit/orm2-schema": "0.0.0-20250331181319",
-    "@casekit/toolbox": "0.0.0-20250331181319"
+    "@casekit/sql": "0.0.0",
+    "@casekit/orm2-config": "0.0.0",
+    "@casekit/orm2-schema": "0.0.0",
+    "@casekit/toolbox": "0.0.0"
   },
   "devDependencies": {
     "@casekit/unindent": "^1.0.5",
-    "@eslint/js": "^9.23.0",
-    "@faker-js/faker": "^9.6.0",
+    "@eslint/js": "^9.29.0",
+    "@faker-js/faker": "^9.8.0",
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@types/node": "^22.13.13",
+    "@types/node": "^24.0.3",
     "@types/object-hash": "^3.0.6",
-    "@types/pg": "^8.11.11",
+    "@types/pg": "^8.15.4",
     "@types/uuid": "^10.0.0",
-    "@vitest/coverage-v8": "^3.0.9",
-    "dotenv": "^16.4.7",
+    "@vitest/coverage-v8": "^3.2.4",
+    "dotenv": "^16.5.0",
     "prettier": "^3.5.3",
-    "prettier-plugin-svelte": "^3.3.3",
-    "ts-essentials": "^10.0.4",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.28.0",
+    "prettier-plugin-svelte": "^3.4.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/orm2-fixtures": "0.0.0-20250331181319",
-    "@casekit/orm2-testing": "0.0.0-20250331181319",
-    "@casekit/prettier-config": "0.0.0-20250331181319",
-    "@casekit/tsconfig": "0.0.0-20250331181319"
+    "vitest": "^3.2.4",
+    "@casekit/orm2-fixtures": "0.0.0",
+    "@casekit/orm2-testing": "0.0.0",
+    "@casekit/tsconfig": "0.0.0",
+    "@casekit/prettier-config": "0.0.0"
   },
   "exports": {
     ".": "./build/index.js"
@@ -47,10 +47,9 @@
   },
   "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",