@casekit/orm2 0.0.0-20250331202540 → 0.0.0

package/build/builders/buildWhere.test.js

@@ -24,131 +24,146 @@ describe("buildWhere", () => {
     };
     test("builds simple equality clause", () => {
         const where = { id: 1 };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" = $1');
         expect(result.values).toEqual([1]);
     });
     test("builds IS NULL clause", () => {
         const where = { name: null };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."name" IS NULL');
     });
     test("builds boolean clauses", () => {
         const whereTrue = { active: true };
         const whereFalse = { active: false };
-        expect(buildWhere(db.config, table, whereTrue).text).toBe('"u"."active" IS TRUE');
-        expect(buildWhere(db.config, table, whereFalse).text).toBe('"u"."active" IS FALSE');
+        expect(buildWhere(db.config, [], table, whereTrue).text).toBe('"u"."active" IS TRUE');
+        expect(buildWhere(db.config, [], table, whereFalse).text).toBe('"u"."active" IS FALSE');
     });
     test("builds AND clause", () => {
         const where = { [$and]: [{ id: 1 }, { name: "test" }] };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('("u"."id" = $1 AND "u"."name" = $2)');
         expect(result.values).toEqual([1, "test"]);
     });
     test("builds OR clause", () => {
         const where = { [$or]: [{ id: 1 }, { name: "test" }] };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('("u"."id" = $1 OR "u"."name" = $2)');
         expect(result.values).toEqual([1, "test"]);
     });
     test("builds NOT clause", () => {
         const where = { [$not]: { active: true } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('NOT "u"."active" IS TRUE');
     });
     test("throws error for unrecognized field", () => {
         const where = { unknownField: 1 };
-        expect(() => buildWhere(db.config, table, where)).toThrow("Unrecognised field");
+        expect(() => buildWhere(db.config, [], table, where)).toThrow("Unrecognised field");
     });
     test("handles Date objects", () => {
         const date = new Date("2023-01-01");
         const where = { createdAt: date };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."created_at" = $1');
         expect(result.values).toEqual([date]);
     });
     test("builds $eq operator clause", () => {
         const where = { id: { [$eq]: 1 } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" = $1');
         expect(result.values).toEqual([1]);
     });
     test("builds $gt operator clause", () => {
         const where = { id: { [$gt]: 1 } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" > $1');
         expect(result.values).toEqual([1]);
     });
     test("builds $gte operator clause", () => {
         const where = { id: { [$gte]: 1 } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" >= $1');
         expect(result.values).toEqual([1]);
     });
     test("builds $ilike operator clause", () => {
         const where = { name: { [$ilike]: "%test%" } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."name" ILIKE $1');
         expect(result.values).toEqual(["%test%"]);
     });
     test("builds $is operator clause", () => {
         const where = { name: { [$is]: null } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."name" IS NULL');
         expect(result.values).toEqual([]);
     });
     test("builds $not operator clause", () => {
         const where = { name: { [$not]: null } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."name" IS NOT NULL');
         expect(result.values).toEqual([]);
     });
     test("builds $like operator clause", () => {
         const where = { name: { [$like]: "%test%" } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."name" LIKE $1');
         expect(result.values).toEqual(["%test%"]);
     });
     test("builds $lt operator clause", () => {
         const where = { id: { [$lt]: 1 } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" < $1');
         expect(result.values).toEqual([1]);
     });
     test("builds $lte operator clause", () => {
         const where = { id: { [$lte]: 1 } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" <= $1');
         expect(result.values).toEqual([1]);
     });
     test("builds $ne operator clause", () => {
         const where = { id: { [$ne]: 1 } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" != $1');
         expect(result.values).toEqual([1]);
     });
     test("builds $not operator clause with null", () => {
         const where = { name: { [$not]: null } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."name" IS NOT NULL');
     });
     test("throws error when $not operator receives non-null or boolean value", () => {
         const where = { name: { [$not]: "test" } };
-        expect(() => buildWhere(db.config, table, where)).toThrow("Invalid value passed to $not operator");
+        expect(() => buildWhere(db.config, [], table, where)).toThrow("Invalid value passed to $not operator");
     });
     test("builds $in operator clause", () => {
         const where = { id: { [$in]: [1, 2, 3] } };
-        const result = buildWhere(db.config, table, where);
+        const result = buildWhere(db.config, [], table, where);
         expect(result.text).toBe('"u"."id" IN ($1, $2, $3)');
         expect(result.values).toEqual([1, 2, 3]);
     });
     test("throws error when $in operator receives non-array value", () => {
         const where = { id: { [$in]: 1 } };
-        expect(() => buildWhere(db.config, table, where)).toThrow("Non-array passed to IN clause");
+        expect(() => buildWhere(db.config, [], table, where)).toThrow("Non-array passed to IN clause");
     });
     test("throws error for unrecognised operator", () => {
         const unknownSymbol = Symbol("unknown");
         const where = { id: { [unknownSymbol]: 1 } };
-        expect(() => buildWhere(db.config, table, where)).toThrow("Unrecognised query operator or value");
+        expect(() => buildWhere(db.config, [], table, where)).toThrow("Unrecognised query operator or value");
+    });
+    test("applies where middleware", () => {
+        const middleware = [
+            {
+                where: (_config, _modelName, where) => {
+                    // Add a soft delete filter
+                    return { active: true, ...where };
+                },
+            },
+        ];
+        const where = { id: 1 };
+        const result = buildWhere(db.config, middleware, table, where);
+        // Should include both the original where clause and the middleware-added clause
+        expect(result.text).toBe('"u"."active" IS TRUE AND "u"."id" = $1');
+        expect(result.values).toEqual([1]);
     });
 });

package/build/connection.d.ts

@@ -11,7 +11,7 @@ export declare class Connection {
     constructor(config: NormalizedConfig);
     connect(): Promise<void>;
     close(): Promise<void>;
-    query<T extends QueryResultRow>(sql: SQLStatement): Promise<pg.QueryResult<T>>;
+    query<T extends QueryResultRow>(sql: SQLStatement): Promise<import("pg").QueryResult<T>>;
     startTransaction(): Promise<Transaction>;
     isTransaction(): boolean;
 }
@@ -22,7 +22,7 @@ export declare class Transaction extends Connection {
     constructor(config: NormalizedConfig, client?: pg.Client | null, pool?: pg.Pool | null, poolClient?: pg.PoolClient | null, nested?: boolean);
     connect(): Promise<void>;
     close(): Promise<void>;
-    query<T extends QueryResultRow>(sql: SQLStatement): Promise<pg.QueryResult<T>>;
+    query<T extends QueryResultRow>(sql: SQLStatement): Promise<import("pg").QueryResult<T>>;
     startTransaction(): Promise<Transaction>;
     begin(): Promise<void>;
     rollback(): Promise<void>;

package/build/index.d.ts

@@ -1,4 +1,4 @@
-export * as op from "./operators.js";
+export * from "./operators.js";
 export { orm, type Orm } from "./orm.js";
 export type { Config, FieldDefinition, ForeignKeyDefinition, ModelDefinition, ModelDefinitions, ModelType, PostgresDataTypes, RelationDefinition, UniqueConstraintDefinition, } from "@casekit/orm2-schema";
 export type { FindParams } from "./types/FindParams.js";

package/build/index.js

@@ -1,5 +1,5 @@
 /* v8 ignore start */
-export * as op from "./operators.js";
+export * from "./operators.js";
 export { orm } from "./orm.js";
 export { sql, SQLStatement } from "@casekit/sql";
 /* v8 ignore stop */

package/build/orm.count.d.ts

@@ -2,13 +2,5 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinition, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { CountParams } from "./types/CountParams.js";
-/**
- * Executes a count query against the database.
- *
- * @param config The normalized ORM configuration
- * @param conn The database connection
- * @param modelName The name of the model to count records for
- * @param query Parameters for the count query, including where and include clauses
- * @returns The number of matching records
- */
-export declare const count: (config: NormalizedConfig, conn: Connection, modelName: string, query: CountParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => Promise<number>;
+import { Middleware } from "./types/Middleware.js";
+export declare const count: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: CountParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>) => Promise<number>;

package/build/orm.count.js

@@ -1,17 +1,8 @@
 import { z } from "zod";
 import { buildCount } from "./builders/buildCount.js";
 import { countToSql } from "./sql/countToSql.js";
-/**
- * Executes a count query against the database.
- *
- * @param config The normalized ORM configuration
- * @param conn The database connection
- * @param modelName The name of the model to count records for
- * @param query Parameters for the count query, including where and include clauses
- * @returns The number of matching records
- */
-export const count = async (config, conn, modelName, query) => {
-    const builder = buildCount(config, modelName, query);
+export const count = async (config, conn, middleware, modelName, query) => {
+    const builder = buildCount(config, middleware, modelName, query);
     const statement = countToSql(builder);
     config.logger.info("Executing count", {
         sql: statement.pretty,

package/build/orm.createMany.d.ts

@@ -2,4 +2,5 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { CreateManyParams } from "./types/CreateManyParams.js";
-export declare const createMany: (config: NormalizedConfig, conn: Connection, modelName: string, query: CreateManyParams<ModelDefinitions, string>) => Promise<Record<string, unknown>[] | number>;
+import { Middleware } from "./types/Middleware.js";
+export declare const createMany: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: CreateManyParams<ModelDefinitions, string>) => Promise<Record<string, unknown>[] | number>;

package/build/orm.createMany.js

@@ -1,11 +1,11 @@
 import { buildCreate } from "./builders/buildCreate.js";
 import { createToSql } from "./sql/createToSql.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const createMany = async (config, conn, modelName, query) => {
+export const createMany = async (config, conn, middleware, modelName, query) => {
     if (query.values.length === 0) {
         return query.returning ? [] : 0;
     }
-    const builder = buildCreate(config, modelName, query);
+    const builder = buildCreate(config, middleware, modelName, query);
     const statement = createToSql(builder);
     config.logger.info("Executing createMany", {
         sql: statement.pretty,

package/build/orm.createOne.d.ts

@@ -2,4 +2,5 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { CreateOneParams } from "./types/CreateOneParams.js";
-export declare const createOne: (config: NormalizedConfig, conn: Connection, modelName: string, { values, ...query }: CreateOneParams<ModelDefinitions, string>) => Promise<Record<string, unknown> | number | null>;
+import { Middleware } from "./types/Middleware.js";
+export declare const createOne: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, { values, ...query }: CreateOneParams<ModelDefinitions, string>) => Promise<Record<string, unknown> | number | null>;

package/build/orm.createOne.js

@@ -1,8 +1,8 @@
 import { buildCreate } from "./builders/buildCreate.js";
 import { createToSql } from "./sql/createToSql.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const createOne = async (config, conn, modelName, { values, ...query }) => {
-    const builder = buildCreate(config, modelName, {
+export const createOne = async (config, conn, middleware, modelName, { values, ...query }) => {
+    const builder = buildCreate(config, middleware, modelName, {
         ...query,
         values: [values],
     });

package/build/orm.d.ts

@@ -1,6 +1,6 @@
 import { QueryResultRow } from "pg";
 import { DeepReadonly } from "ts-essentials";
-import { ZodSchema } from "zod";
+import { ZodType } from "zod";
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { Config, ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
 import { SQLStatement } from "@casekit/sql";
@@ -21,7 +21,7 @@ import { RestrictModels } from "./types/RestrictModels.js";
 import { UpdateManyResult } from "./types/UpdateManyResult.js";
 import { UpdateOneResult } from "./types/UpdateOneResult.js";
 import { UpdateParams } from "./types/UpdateParams.js";
-export declare const orm: <const C extends Config>(config: Conform<Config, C>) => Orm<C>;
+export declare const orm: <const C extends Config>(config: C) => Orm<C>;
 export declare class Orm<const C extends Config = Config, const Models extends ModelDefinitions = C["models"], const Operators extends OperatorDefinitions = C["operators"] extends NonNullable<C["operators"]> ? C["operators"] : {
     where: never;
 }> {
@@ -65,7 +65,7 @@ export declare class Orm<const C extends Config = Config, const Models extends M
      *     SELECT foo FROM table WHERE foo = ${value}
      * `;
      */
-    query<const ResultType extends QueryResultRow = QueryResultRow>(schema: ZodSchema<ResultType>): (fragments: TemplateStringsArray, ...values: unknown[]) => Promise<ResultType[]>;
+    query<const ResultType extends QueryResultRow = QueryResultRow>(schema: ZodType<ResultType>): (fragments: TemplateStringsArray, ...values: unknown[]) => Promise<ResultType[]>;
     /**
      * const statement = sql<{ one: number }>`SELECT 1 as one`;
      * await db.query(statement);

package/build/orm.deleteMany.d.ts

@@ -2,4 +2,5 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { DeleteParams } from "./types/DeleteParams.js";
-export declare const deleteMany: (config: NormalizedConfig, conn: Connection, modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;
+import { Middleware } from "./types/Middleware.js";
+export declare const deleteMany: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;

package/build/orm.deleteMany.js

@@ -1,8 +1,8 @@
 import { buildDelete } from "./builders/buildDelete.js";
 import { deleteToSql } from "./sql/deleteToSql.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const deleteMany = async (config, conn, modelName, query) => {
-    const builder = buildDelete(config, modelName, query);
+export const deleteMany = async (config, conn, middleware, modelName, query) => {
+    const builder = buildDelete(config, middleware, modelName, query);
     const statement = deleteToSql(builder);
     config.logger.info("Executing deleteMany", {
         sql: statement.pretty,

package/build/orm.deleteOne.d.ts

@@ -2,4 +2,5 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { DeleteParams } from "./types/DeleteParams.js";
-export declare const deleteOne: (config: NormalizedConfig, conn: Connection, modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;
+import { Middleware } from "./types/Middleware.js";
+export declare const deleteOne: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;

package/build/orm.deleteOne.js

@@ -1,8 +1,8 @@
 import { buildDelete } from "./builders/buildDelete.js";
 import { deleteToSql } from "./sql/deleteToSql.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const deleteOne = async (config, conn, modelName, query) => {
-    const builder = buildDelete(config, modelName, query);
+export const deleteOne = async (config, conn, middleware, modelName, query) => {
+    const builder = buildDelete(config, middleware, modelName, query);
     const statement = deleteToSql(builder);
     config.logger.info("Executing deleteOne", {
         sql: statement.pretty,

package/build/orm.findMany.d.ts

@@ -2,7 +2,8 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinition, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { FindParams } from "./types/FindParams.js";
-export declare const findMany: (config: NormalizedConfig, conn: Connection, modelName: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>, lateralBy?: {
+import { Middleware } from "./types/Middleware.js";
+export declare const findMany: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>, lateralBy?: {
     field: string;
     values: unknown[];
 }[]) => Promise<Record<string, unknown>[]>;

package/build/orm.findMany.js

@@ -6,8 +6,8 @@ import { findToSql } from "./sql/findToSql.js";
 import { getIncludedToManySubqueries } from "./util/getIncludedToManySubqueries.js";
 import { getLateralJoinValues } from "./util/getLateralJoinValues.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const findMany = async (config, conn, modelName, query, lateralBy = []) => {
-    const builder = buildFind(config, modelName, query, lateralBy);
+export const findMany = async (config, conn, middleware, modelName, query, lateralBy = []) => {
+    const builder = buildFind(config, middleware, modelName, query, lateralBy);
     const statement = findToSql(builder);
     config.logger.info("Executing findMany", {
         sql: statement.pretty,
@@ -26,7 +26,7 @@ export const findMany = async (config, conn, modelName, query, lateralBy = []) =
         const lateralBy = getLateralJoinValues(results, dropRight(path, 1), from, to);
         // rather than awaiting the findMany query here, we'll push a promise
         // into an array that we can await in parallel later.
-        const promise = findMany(config, conn, modelName, query, lateralBy).then((relationResults) => {
+        const promise = findMany(config, conn, middleware, modelName, query, lateralBy).then((relationResults) => {
             // we group the results by the hash of the 'to' columns so
             // we can find the right list of values for each result
             const lookup = groupBy(relationResults, (result) => hash(to.map((f) => result[f])));

package/build/orm.findOne.d.ts

@@ -2,4 +2,5 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { FindParams } from "./types/FindParams.js";
-export declare const findOne: (config: NormalizedConfig, conn: Connection, model: string, query: FindParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>>;
+import { Middleware } from "./types/Middleware.js";
+export declare const findOne: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: FindParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>>;

package/build/orm.findOne.js

@@ -1,20 +1,12 @@
-import { buildFind } from "./builders/buildFind.js";
-import { findToSql } from "./sql/findToSql.js";
-import { rowToObject } from "./util/rowToObject.js";
-export const findOne = async (config, conn, model, query) => {
-    const builder = buildFind(config, model, { ...query, limit: 2 });
-    const statement = findToSql(builder);
-    config.logger.info("Executing findOne", {
-        sql: statement.pretty,
-        values: statement.values,
-    });
-    return await conn.query(statement).then((res) => {
-        if (res.rows.length === 0) {
-            throw new Error("Expected one row, but found none");
-        }
-        if (res.rows.length > 1) {
-            throw new Error("Expected one row, but found more");
-        }
-        return res.rows.map((row) => rowToObject(row, builder.columns))[0];
-    });
+import { findMany } from "./orm.findMany.js";
+export const findOne = async (config, conn, middleware, modelName, query) => {
+    config.logger.info("Delegating findOne to findMany");
+    const results = await findMany(config, conn, middleware, modelName, query);
+    if (results.length === 0) {
+        throw new Error("Expected one row, but found none");
+    }
+    if (results.length > 1) {
+        throw new Error("Expected one row, but found more");
+    }
+    return results[0];
 };

package/build/orm.js

@@ -8,7 +8,7 @@
  * the general - and nowhere else in the project should be doing this.
  */
 import { mapValues, pick, pickBy } from "es-toolkit";
-import { ZodSchema, z } from "zod";
+import { ZodType, z } from "zod";
 import { getModel, normalizeConfig, } from "@casekit/orm2-config";
 import { SQLStatement, sql } from "@casekit/sql";
 import { Connection } from "./connection.js";
@@ -43,7 +43,7 @@ export class Orm {
     async transact(fn, options = { rollback: false }) {
         const tx = await this._connection.startTransaction();
         try {
-            const result = await fn(new Orm(this.config, tx));
+            const result = await fn(new Orm(this.config, tx, this._middleware));
             if (options.rollback) {
                 await tx.rollback();
             }
@@ -78,7 +78,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await findOne(this.config, this._connection, modelName, query);
+        const result = await findOne(this.config, this._connection, this._middleware, modelName, query);
         const schema = findOneResultSchema(this.config, modelName, query);
         return schema.parse(result);
     }
@@ -90,7 +90,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await findMany(this.config, this._connection, modelName, query);
+        const result = await findMany(this.config, this._connection, this._middleware, modelName, query);
         const schema = findManyResultSchema(this.config, modelName, query);
         return schema.parse(result);
     }
@@ -102,7 +102,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        return await count(this.config, this._connection, modelName, query);
+        return await count(this.config, this._connection, this._middleware, modelName, query);
     }
     async createOne(modelName, query) {
         const [mw, next] = this.getNextMiddleware("createOne");
@@ -112,7 +112,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await createOne(this.config, this._connection, modelName, query);
+        const result = await createOne(this.config, this._connection, this._middleware, modelName, query);
         const schema = returningOneResultSchema(getModel(this.config.models, modelName), query.returning);
         return schema.parse(result);
     }
@@ -124,7 +124,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await createMany(this.config, this._connection, modelName, query);
+        const result = await createMany(this.config, this._connection, this._middleware, modelName, query);
         const schema = returningManyResultSchema(getModel(this.config.models, modelName), query.returning);
         return schema.parse(result);
     }
@@ -136,7 +136,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await updateOne(this.config, this._connection, modelName, query);
+        const result = await updateOne(this.config, this._connection, this._middleware, modelName, query);
         const schema = returningOneResultSchema(getModel(this.config.models, modelName), query.returning);
         return schema.parse(result);
     }
@@ -148,7 +148,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await updateMany(this.config, this._connection, modelName, query);
+        const result = await updateMany(this.config, this._connection, this._middleware, modelName, query);
         const schema = returningManyResultSchema(getModel(this.config.models, modelName), query.returning);
         return schema.parse(result);
     }
@@ -160,7 +160,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await deleteOne(this.config, this._connection, modelName, query);
+        const result = await deleteOne(this.config, this._connection, this._middleware, modelName, query);
         const schema = returningOneResultSchema(getModel(this.config.models, modelName), query.returning);
         return schema.parse(result);
     }
@@ -172,7 +172,7 @@ export class Orm {
             // otherwise typescript goes absolutely haywire causing an OOM error
             return (await mw(db, modelName, query));
         }
-        const result = await deleteMany(this.config, this._connection, modelName, query);
+        const result = await deleteMany(this.config, this._connection, this._middleware, modelName, query);
         const schema = returningManyResultSchema(getModel(this.config.models, modelName), query.returning);
         return schema.parse(result);
     }
@@ -198,7 +198,7 @@ export class Orm {
                 allowed.includes(r.model)),
             })),
         };
-        return new Orm(config, this._connection);
+        return new Orm(config, this._connection, this._middleware);
     }
     /** Returns a new ORM instance with middleware applied.
      * The new ORM instance shares the same connection as
@@ -211,7 +211,7 @@ export class Orm {
         return new Orm(this.config, this._connection, middleware);
     }
     query(schemaOrStatementOrFragments, ...values) {
-        if (schemaOrStatementOrFragments instanceof ZodSchema) {
+        if (schemaOrStatementOrFragments instanceof ZodType) {
             return this.queryWithSchema(schemaOrStatementOrFragments);
         }
         if (schemaOrStatementOrFragments instanceof SQLStatement) {

package/build/orm.restrict.d.ts

@@ -2,5 +2,6 @@ import { NormalizedConfig } from "@casekit/orm2-config";
 import { Config, ModelName } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
 import { Orm } from "./orm.js";
+import { Middleware } from "./types/Middleware.js";
 import { RestrictModels } from "./types/RestrictModels.js";
-export declare const restrict: <const C extends Config, const Allowed extends [...ModelName<C["models"]>[]]>(config: NormalizedConfig, allowed: string[], connection: Connection) => Orm<RestrictModels<C, Allowed[number]>>;
+export declare const restrict: <const C extends Config, const Allowed extends [...ModelName<C["models"]>[]]>(config: NormalizedConfig, allowed: string[], connection: Connection, middleware: Middleware[]) => Orm<RestrictModels<C, Allowed[number]>>;

package/build/orm.restrict.js

@@ -1,5 +1,5 @@
 import { Orm } from "./orm.js";
-export const restrict = (config, allowed, connection) => {
+export const restrict = (config, allowed, connection, middleware) => {
     if (connection.isTransaction()) {
         throw new Error("Cannot create restricted ORM in a transaction");
     }
@@ -48,5 +48,5 @@ export const restrict = (config, allowed, connection) => {
             };
         }
     }, {});
-    return new Orm({ ...config, models }, connection);
+    return new Orm({ ...config, models }, connection, middleware);
 };

package/build/orm.updateMany.d.ts

@@ -1,5 +1,6 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
+import { Middleware } from "./types/Middleware.js";
 import { UpdateParams } from "./types/UpdateParams.js";
-export declare const updateMany: (config: NormalizedConfig, conn: Connection, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;
+export declare const updateMany: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;

package/build/orm.updateMany.js

@@ -1,13 +1,13 @@
 import { buildUpdate } from "./builders/buildUpdate.js";
 import { updateToSql } from "./sql/updateToSql.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const updateMany = async (config, conn, modelName, query) => {
+export const updateMany = async (config, conn, middleware, modelName, query) => {
     if (Object.keys(query.set).length === 0) {
         throw new Error("Update requires at least one value to set");
     }
-    const builder = buildUpdate(config, modelName, query);
+    const builder = buildUpdate(config, middleware, modelName, query);
     const statement = updateToSql(builder);
-    config.logger.info("Executing updateOne", {
+    config.logger.info("Executing updateMany", {
         sql: statement.pretty,
         values: statement.values,
     });

package/build/orm.updateOne.d.ts

@@ -1,5 +1,6 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm2-schema";
 import { Connection } from "./connection.js";
+import { Middleware } from "./types/Middleware.js";
 import { UpdateParams } from "./types/UpdateParams.js";
-export declare const updateOne: (config: NormalizedConfig, conn: Connection, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;
+export declare const updateOne: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;

package/build/orm.updateOne.js

@@ -1,11 +1,11 @@
 import { buildUpdate } from "./builders/buildUpdate.js";
 import { updateToSql } from "./sql/updateToSql.js";
 import { rowToObject } from "./util/rowToObject.js";
-export const updateOne = async (config, conn, modelName, query) => {
+export const updateOne = async (config, conn, middleware, modelName, query) => {
     if (Object.keys(query.set).length === 0) {
         throw new Error("Update requires at least one value to set");
     }
-    const builder = buildUpdate(config, modelName, query);
+    const builder = buildUpdate(config, middleware, modelName, query);
     const statement = updateToSql(builder);
     config.logger.info("Executing updateOne", {
         sql: statement.pretty,