@casekit/orm2 0.0.0-20250331181319 → 0.0.0

package/build/builders/buildCount.d.ts

@@ -12,6 +12,7 @@
  */
 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";
 import { CountBuilder } from "./types.js";
 type BaseCountParams = {
@@ -19,5 +20,5 @@ type BaseCountParams = {
     include?: Record<string, BaseCountParams>;
     for?: "update" | "no key update" | "share" | "key share";
 };
-export declare const buildCount: (config: NormalizedConfig, modelName: string, query: BaseCountParams, path?: string[], tableIndex?: number) => CountBuilder;
+export declare const buildCount: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: BaseCountParams, path?: string[], tableIndex?: number) => CountBuilder;
 export {};

package/build/builders/buildCount.js

@@ -1,11 +1,10 @@
-import { hasClauses } from "#util/hasClauses.js";
 import { makeTableAlias } from "#util/makeTableAlias.js";
 import { buildWhere } from "./buildWhere.js";
 /**
  * Builds a base CountBuilder, with only columns from the main table.
  * Joins will be added later.
  */
-const buildBaseCount = (config, m, query, tableIndex = 0) => {
+const buildBaseCount = (config, middleware, m, query, tableIndex = 0) => {
     const model = config.models[m];
     if (!model)
         throw new Error(`Model "${m}" not found`);
@@ -15,9 +14,7 @@ const buildBaseCount = (config, m, query, tableIndex = 0) => {
         alias: makeTableAlias(tableIndex++),
         model: m,
     };
-    const where = hasClauses(query.where)
-        ? buildWhere(config, table, query.where)
-        : null;
+    const where = buildWhere(config, middleware, table, query.where);
     return {
         table,
         where,
@@ -26,17 +23,17 @@ const buildBaseCount = (config, m, query, tableIndex = 0) => {
         tableIndex,
     };
 };
-export const buildCount = (config, modelName, query, path = [], tableIndex = 0) => {
+export const buildCount = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
     const model = config.models[modelName];
     if (!model)
         throw new Error(`Model "${modelName}" not found`);
-    const builder = buildBaseCount(config, modelName, query, tableIndex);
+    const builder = buildBaseCount(config, middleware, modelName, query, tableIndex);
     for (const [r, subquery] of Object.entries(query.include ?? {})) {
         const relation = model.relations[r];
         if (relation.type !== "N:1") {
             continue;
         }
-        const joinBuilder = buildCount(config, relation.model, subquery, [...path, r], builder.tableIndex);
+        const joinBuilder = buildCount(config, middleware, relation.model, subquery, [...path, r], builder.tableIndex);
         builder.joins.push({
             path: [...path, r],
             relation: r,

package/build/builders/buildCount.test.js

@@ -5,7 +5,7 @@ import { buildCount } from "./buildCount.js";
 describe("buildCount", () => {
     const { db } = createTestDB();
     test("builds basic count query", () => {
-        const result = buildCount(db.config, "post", {});
+        const result = buildCount(db.config, [], "post", {});
         expect(result).toEqual({
             table: {
                 schema: "orm",
@@ -20,7 +20,7 @@ describe("buildCount", () => {
         });
     });
     test("builds count query with N:1 relation include", () => {
-        const result = buildCount(db.config, "post", {
+        const result = buildCount(db.config, [], "post", {
             where: { id: 1 },
             include: {
                 author: {
@@ -61,7 +61,7 @@ describe("buildCount", () => {
         });
     });
     test("builds count query with where clause", () => {
-        const result = buildCount(db.config, "post", {
+        const result = buildCount(db.config, [], "post", {
             where: {
                 title: "Test Post",
             },
@@ -80,7 +80,7 @@ describe("buildCount", () => {
         });
     });
     test("builds count query with nested includes and where clauses", () => {
-        const result = buildCount(db.config, "post", {
+        const result = buildCount(db.config, [], "post", {
             where: {
                 title: "Test Post",
             },
@@ -125,7 +125,7 @@ describe("buildCount", () => {
         });
     });
     test("builds count query with for parameter", () => {
-        const result = buildCount(db.config, "post", {
+        const result = buildCount(db.config, [], "post", {
             for: "update",
         });
         expect(result).toEqual({

package/build/builders/buildCreate.d.ts

@@ -1,5 +1,6 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, ModelName } from "@casekit/orm2-schema";
 import { CreateManyParams } from "#types/CreateManyParams.js";
+import { Middleware } from "../types/Middleware.js";
 import { CreateBuilder } from "./types.js";
-export declare const buildCreate: (config: NormalizedConfig, modelName: string, query: CreateManyParams<ModelDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => CreateBuilder;
+export declare const buildCreate: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: CreateManyParams<ModelDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => CreateBuilder;

package/build/builders/buildCreate.js

@@ -1,10 +1,13 @@
 import { uniq } from "es-toolkit";
 import { makeTableAlias } from "#util/makeTableAlias.js";
-export const buildCreate = (config, modelName, query, path = [], tableIndex = 0) => {
+import { applyValuesMiddleware } from "../util/applyValuesMiddleware.js";
+export const buildCreate = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
     const model = config.models[modelName];
     if (!model)
         throw new Error(`Model "${modelName}" not found`);
-    const fields = uniq(query.values.flatMap(Object.keys));
+    // Apply values middleware to each value object
+    const processedValues = query.values.map((v) => applyValuesMiddleware(config, middleware, modelName, v));
+    const fields = uniq(processedValues.flatMap(Object.keys));
     const table = {
         schema: model.schema,
         name: model.table,
@@ -12,7 +15,7 @@ export const buildCreate = (config, modelName, query, path = [], tableIndex = 0)
         model: modelName,
     };
     const columns = fields.map((f) => model.fields[f].column);
-    const values = query.values.map((v) => fields.map((f) => v[f] ?? null));
+    const values = processedValues.map((v) => fields.map((f) => v[f] ?? null));
     const returning = query.returning?.map((f, index) => ({
         name: model.fields[f].column,
         alias: `${table.alias}_${index}`,

package/build/builders/buildCreate.test.js

@@ -4,7 +4,7 @@ import { buildCreate } from "./buildCreate.js";
 describe("buildCreate", () => {
     const { db } = createTestDB();
     test("should build a create query", () => {
-        const result = buildCreate(db.config, "user", {
+        const result = buildCreate(db.config, [], "user", {
             values: [{ id: 1, name: "John Doe", email: "john@example.com" }],
         });
         expect(result).toEqual({
@@ -21,14 +21,14 @@ describe("buildCreate", () => {
         });
     });
     test("should throw an error if model is not found", () => {
-        expect(() => buildCreate(db.config, "NonExistentModel", {
+        expect(() => buildCreate(db.config, [], "NonExistentModel", {
             values: [
                 { id: 1, name: "John Doe", email: "john@example.com" },
             ],
         })).toThrow('Model "NonExistentModel" not found');
     });
     test("should handle returning fields", () => {
-        const result = buildCreate(db.config, "user", {
+        const result = buildCreate(db.config, [], "user", {
             values: [{ id: 1, name: "John Doe", email: "john@example.com" }],
             returning: ["id", "name"],
         });
@@ -38,7 +38,7 @@ describe("buildCreate", () => {
         ]);
     });
     test("should handle onConflict", () => {
-        const result = buildCreate(db.config, "user", {
+        const result = buildCreate(db.config, [], "user", {
             values: [{ id: 1, name: "John Doe", email: "john@example.com" }],
             onConflict: { do: "nothing" },
         });

package/build/builders/buildDelete.d.ts

@@ -1,5 +1,6 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
 import { DeleteParams } from "#types/DeleteParams.js";
+import { Middleware } from "../types/Middleware.js";
 import { DeleteBuilder } from "./types.js";
-export declare const buildDelete: (config: NormalizedConfig, modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => DeleteBuilder;
+export declare const buildDelete: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: DeleteParams<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => DeleteBuilder;

package/build/builders/buildDelete.js

@@ -1,7 +1,7 @@
 import { makeTableAlias } from "#util/makeTableAlias.js";
 import { hasClauses } from "../util/hasClauses.js";
 import { buildWhere } from "./buildWhere.js";
-export const buildDelete = (config, modelName, query, path = [], tableIndex = 0) => {
+export const buildDelete = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
     const model = config.models[modelName];
     if (!model)
         throw new Error(`Model "${modelName}" not found`);
@@ -14,7 +14,7 @@ export const buildDelete = (config, modelName, query, path = [], tableIndex = 0)
     if (!hasClauses(query.where)) {
         throw new Error("Delete queries must have a where clause");
     }
-    const where = buildWhere(config, table, query.where);
+    const where = buildWhere(config, middleware, table, query.where);
     const returning = query.returning?.map((f, index) => ({
         name: model.fields[f].column,
         alias: `${table.alias}_${index}`,

package/build/builders/buildDelete.test.js

@@ -5,7 +5,7 @@ import { buildDelete } from "./buildDelete.js";
 describe("buildDelete", () => {
     const { db } = createTestDB();
     test("builds basic delete query with where clause", () => {
-        const result = buildDelete(db.config, "user", {
+        const result = buildDelete(db.config, [], "user", {
             where: { id: 1 },
         });
         expect(result).toEqual({
@@ -20,7 +20,7 @@ describe("buildDelete", () => {
         });
     });
     test("builds delete query with returning clause", () => {
-        const result = buildDelete(db.config, "user", {
+        const result = buildDelete(db.config, [], "user", {
             where: { id: 1 },
             returning: ["id", "name"],
         });
@@ -47,23 +47,23 @@ describe("buildDelete", () => {
         });
     });
     test("throws error when model not found", () => {
-        expect(() => buildDelete(db.config, "nonexistentModel", {
+        expect(() => buildDelete(db.config, [], "nonexistentModel", {
             where: { id: 1 },
         })).toThrow('Model "nonexistentModel" not found');
     });
     test("throws error when where clause is empty", () => {
-        expect(() => buildDelete(db.config, "user", {
+        expect(() => buildDelete(db.config, [], "user", {
             where: {},
         })).toThrow("Delete queries must have a where clause");
     });
     test("throws error when where clause is undefined", () => {
-        expect(() => buildDelete(db.config, "user", {
+        expect(() => buildDelete(db.config, [], "user", {
             // @ts-expect-error testing runtime behavior with invalid input
             where: undefined,
         })).toThrow("Delete queries must have a where clause");
     });
     test("handles complex where clauses", () => {
-        const result = buildDelete(db.config, "user", {
+        const result = buildDelete(db.config, [], "user", {
             where: {
                 id: 1,
                 name: "test",
@@ -82,7 +82,7 @@ describe("buildDelete", () => {
         });
     });
     test("uses correct path for nested fields in returning clause", () => {
-        const result = buildDelete(db.config, "user", {
+        const result = buildDelete(db.config, [], "user", {
             where: { id: 1 },
             returning: ["id", "name"],
         }, ["parent"]);
@@ -100,7 +100,7 @@ describe("buildDelete", () => {
         ]);
     });
     test("uses provided table index for alias generation", () => {
-        const result = buildDelete(db.config, "user", {
+        const result = buildDelete(db.config, [], "user", {
             where: { id: 1 },
         }, [], 5);
         expect(result.table.alias).toBe("f");

package/build/builders/buildFind.d.ts

@@ -1,8 +1,9 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinition, OperatorDefinitions } from "@casekit/orm2-schema";
 import { FindParams } from "#types/FindParams.js";
+import { Middleware } from "../types/Middleware.js";
 import { FindBuilder } from "./types.js";
-export declare const buildFind: (config: NormalizedConfig, modelName: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>, lateralBy?: {
+export declare const buildFind: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: FindParams<Record<string, Required<ModelDefinition>>, OperatorDefinitions, string>, lateralBy?: {
     field: string;
     values: unknown[];
 }[], path?: string[], tableIndex?: number) => FindBuilder;

package/build/builders/buildFind.js

@@ -13,14 +13,13 @@
 import { pickBy, uniq } from "es-toolkit";
 import { max, min } from "es-toolkit/compat";
 import { getField, } from "@casekit/orm2-config";
-import { hasClauses } from "#util/hasClauses.js";
 import { makeTableAlias } from "#util/makeTableAlias.js";
 import { buildWhere } from "./buildWhere.js";
 /**
  * Builds a base FindBuilder, with only columns from the main table.
  * Joins will be added later.
  */
-const buildBaseFind = (config, m, query, lateralBy = [], path = [], tableIndex = 0) => {
+const buildBaseFind = (config, middleware, m, query, lateralBy = [], path = [], tableIndex = 0) => {
     const model = config.models[m];
     if (!model)
         throw new Error(`Model "${m}" not found`);
@@ -47,9 +46,7 @@ const buildBaseFind = (config, m, query, lateralBy = [], path = [], tableIndex =
             path: [...path, f],
         };
     });
-    const where = hasClauses(query.where)
-        ? buildWhere(config, table, query.where)
-        : null;
+    const where = buildWhere(config, middleware, table, query.where);
     return {
         table,
         columns,
@@ -122,18 +119,18 @@ const buildOrderBy = (config, model, query, builder) => {
         }
     }) ?? []);
 };
-export const buildFind = (config, modelName, query, lateralBy = [], path = [], tableIndex = 0) => {
+export const buildFind = (config, middleware, modelName, query, lateralBy = [], path = [], tableIndex = 0) => {
     const model = config.models[modelName];
     if (!model)
         throw new Error(`Model "${modelName}" not found`);
-    const builder = buildBaseFind(config, modelName, query, lateralBy, path, tableIndex);
+    const builder = buildBaseFind(config, middleware, modelName, query, lateralBy, path, tableIndex);
     const manyToOneQueries = collectManyToOneQueries(model, query);
     for (const [r, subquery] of Object.entries(manyToOneQueries)) {
         const relation = model.relations[r];
         if (relation.type !== "N:1") {
             throw new Error(`Unexpected relation type: ${relation.type}. Should be N:1`);
         }
-        const joinBuilder = buildFind(config, relation.model, subquery, [], [...path, r], builder.tableIndex);
+        const joinBuilder = buildFind(config, middleware, relation.model, subquery, [], [...path, r], builder.tableIndex);
         builder.joins.push({
             relation: r,
             path: [...path, r],

package/build/builders/buildFind.test.js

@@ -4,7 +4,7 @@ import { buildFind } from "./buildFind.js";
 describe("buildFind", () => {
     const { db } = createTestDB();
     test("builds query with N:1 relation include", () => {
-        const result = buildFind(db.config, "post", {
+        const result = buildFind(db.config, [], "post", {
             select: ["id", "title"],
             include: {
                 author: {
@@ -81,7 +81,7 @@ describe("buildFind", () => {
     });
     test("builds query with optional N:1 relation include", () => {
         const { db } = createTestDB();
-        const result = buildFind(db.config, "post", {
+        const result = buildFind(db.config, [], "post", {
             select: ["id"],
             include: {
                 backgroundColor: {
@@ -152,7 +152,7 @@ describe("buildFind", () => {
     });
     test("automatically joins relations referenced in orderBy", () => {
         const { db } = createTestDB();
-        const result = buildFind(db.config, "post", {
+        const result = buildFind(db.config, [], "post", {
             select: ["id", "title"],
             orderBy: ["author.name"],
         });
@@ -227,7 +227,7 @@ describe("buildFind", () => {
     });
     test("combines ordering, limits and offsets from nested queries", () => {
         const { db } = createTestDB();
-        const result = buildFind(db.config, "post", {
+        const result = buildFind(db.config, [], "post", {
             select: ["id"],
             limit: 10,
             offset: 5,

package/build/builders/buildUpdate.d.ts

@@ -1,5 +1,6 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
 import { UpdateParams } from "#types/UpdateParams.js";
+import { Middleware } from "../types/Middleware.js";
 import { UpdateBuilder } from "./types.js";
-export declare const buildUpdate: (config: NormalizedConfig, modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => UpdateBuilder;
+export declare const buildUpdate: (config: NormalizedConfig, middleware: Middleware[], modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>, path?: string[], tableIndex?: number) => UpdateBuilder;

package/build/builders/buildUpdate.js

@@ -1,8 +1,9 @@
 import { getField } from "@casekit/orm2-config";
 import { makeTableAlias } from "#util/makeTableAlias.js";
+import { applySetMiddleware } from "../util/applySetMiddleware.js";
 import { hasClauses } from "../util/hasClauses.js";
 import { buildWhere } from "./buildWhere.js";
-export const buildUpdate = (config, modelName, query, path = [], tableIndex = 0) => {
+export const buildUpdate = (config, middleware, modelName, query, path = [], tableIndex = 0) => {
     const model = config.models[modelName];
     if (!model)
         throw new Error(`Model "${modelName}" not found`);
@@ -12,14 +13,16 @@ export const buildUpdate = (config, modelName, query, path = [], tableIndex = 0)
         alias: makeTableAlias(tableIndex++),
         model: modelName,
     };
-    const set = Object.entries(query.set).map(([field, value]) => [
+    // Apply set middleware before processing
+    const processedSet = applySetMiddleware(config, middleware, modelName, query.set);
+    const set = Object.entries(processedSet).map(([field, value]) => [
         getField(model, field).column,
         value,
     ]);
     if (!hasClauses(query.where)) {
         throw new Error("Update queries must have a where clause");
     }
-    const where = buildWhere(config, table, query.where);
+    const where = buildWhere(config, middleware, table, query.where);
     const returning = query.returning?.map((f, index) => ({
         name: model.fields[f].column,
         alias: `${table.alias}_${index}`,

package/build/builders/buildUpdate.test.js

@@ -7,7 +7,7 @@ import { buildUpdate } from "./buildUpdate.js";
 describe("buildUpdate", () => {
     const { db } = createTestDB();
     test("builds basic update query", () => {
-        const result = buildUpdate(db.config, "user", {
+        const result = buildUpdate(db.config, [], "user", {
             set: { name: "John", email: "john@example.com" },
             where: { id: 1 },
         });
@@ -27,7 +27,7 @@ describe("buildUpdate", () => {
         });
     });
     test("builds update query with returning clause", () => {
-        const result = buildUpdate(db.config, "user", {
+        const result = buildUpdate(db.config, [], "user", {
             set: { name: "John" },
             where: { id: 1 },
             returning: ["id", "name"],
@@ -56,26 +56,26 @@ describe("buildUpdate", () => {
         });
     });
     test("throws error for nonexistent model", () => {
-        expect(() => buildUpdate(db.config, "nonexistent", {
+        expect(() => buildUpdate(db.config, [], "nonexistent", {
             set: { name: "John" },
             where: { id: 1 },
         })).toThrow('Model "nonexistent" not found');
     });
     test("throws error when where clause is empty", () => {
-        expect(() => buildUpdate(db.config, "user", {
+        expect(() => buildUpdate(db.config, [], "user", {
             set: { name: "John" },
             where: {},
         })).toThrow("Update queries must have a where clause");
     });
     test("throws error when where clause is undefined", () => {
-        expect(() => buildUpdate(db.config, "user", {
+        expect(() => buildUpdate(db.config, [], "user", {
             set: { name: "John" },
             // @ts-expect-error testing runtime behavior
             where: undefined,
         })).toThrow("Update queries must have a where clause");
     });
     test("handles nested paths in returning clause", () => {
-        const result = buildUpdate(db.config, "user", {
+        const result = buildUpdate(db.config, [], "user", {
             set: { name: "John" },
             where: { id: 1 },
             returning: ["id", "name"],
@@ -94,14 +94,14 @@ describe("buildUpdate", () => {
         ]);
     });
     test("uses provided table index for alias", () => {
-        const result = buildUpdate(db.config, "user", {
+        const result = buildUpdate(db.config, [], "user", {
             set: { name: "John" },
             where: { id: 1 },
         }, [], 5);
         expect(result.table.alias).toBe("f");
     });
     test("handles complex where clauses", () => {
-        const result = buildUpdate(db.config, "user", {
+        const result = buildUpdate(db.config, [], "user", {
             set: { name: "John" },
             where: {
                 id: 1,

package/build/builders/buildWhere.d.ts

@@ -1,6 +1,7 @@
 import { NormalizedConfig } from "@casekit/orm2-config";
 import { ModelDefinitions, ModelName, OperatorDefinitions } from "@casekit/orm2-schema";
 import { SQLStatement } from "@casekit/sql";
+import { Middleware } from "../types/Middleware.js";
 import { WhereClause } from "../types/WhereClause.js";
 import { Table } from "./types.js";
-export declare const buildWhere: (config: NormalizedConfig, table: Table, where: WhereClause<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>) => SQLStatement;
+export declare const buildWhere: (config: NormalizedConfig, middleware: Middleware[], table: Table, where?: WhereClause<ModelDefinitions, OperatorDefinitions, ModelName<ModelDefinitions>>) => SQLStatement | null;

package/build/builders/buildWhere.js

@@ -1,11 +1,18 @@
 import { sql } from "@casekit/sql";
 import { $and, $not, $or, defaultOperators } from "../operators.js";
-export const buildWhere = (config, table, where) => {
+import { applyWhereMiddleware } from "../util/applyWhereMiddleware.js";
+import { hasClauses } from "../util/hasClauses.js";
+export const buildWhere = (config, middleware, table, where) => {
+    // Apply middleware to the where clause
+    const processedWhere = applyWhereMiddleware(config, middleware, table.model, where) ?? {};
+    if (!hasClauses(processedWhere)) {
+        return null;
+    }
     // NB. Object.entries does not iterate over the symbol keys
     // of an object, so this is a neat way for us to get just the
     // clauses that relate to specific fields, and not logic operators
     // like $and, $or, $not.
-    const clauses = Object.entries(where).map(([field, value]) => {
+    const clauses = Object.entries(processedWhere).map(([field, value]) => {
         const tableAlias = table.alias;
         const column = config.models[table.model]?.fields[field]?.column;
         if (!column)
@@ -47,16 +54,31 @@ export const buildWhere = (config, table, where) => {
         return sql.join(subclauses, " AND ");
     });
     // logical operators
-    if (where[$and]) {
-        const subclauses = where[$and].map((clause) => buildWhere(config, table, clause));
+    if (processedWhere[$and]) {
+        const subclauses = processedWhere[$and].map((clause) => {
+            const subclause = buildWhere(config, middleware, table, clause);
+            if (!subclause) {
+                throw new Error("AND clause must not be empty");
+            }
+            return subclause;
+        });
         clauses.push(sql `(${sql.join(subclauses, " AND ")})`);
     }
-    if (where[$or]) {
-        const subclauses = where[$or].map((clause) => buildWhere(config, table, clause));
+    if (processedWhere[$or]) {
+        const subclauses = processedWhere[$or].map((clause) => {
+            const subclause = buildWhere(config, middleware, table, clause);
+            if (!subclause) {
+                throw new Error("OR clause must not be empty");
+            }
+            return subclause;
+        });
         clauses.push(sql `(${sql.join(subclauses, " OR ")})`);
     }
-    if (where[$not]) {
-        const subclause = buildWhere(config, table, where[$not]);
+    if (processedWhere[$not]) {
+        const subclause = buildWhere(config, middleware, table, processedWhere[$not]);
+        if (!subclause) {
+            throw new Error("NOT clause must not be empty");
+        }
         clauses.push(sql `NOT ${subclause}`);
     }
     return sql.join(clauses, " AND ");