@payloadcms/drizzle 4.0.0-internal.a7ca468 → 4.0.0-internal.af6aad0

package/dist/queries/buildOperatorConstraint.d.ts

@@ -0,0 +1,22 @@
+import type { Column, SQL } from 'drizzle-orm';
+import type { FlattenedField, Operator } from 'payload';
+import type { DrizzleAdapter } from '../types.js';
+import type { DrizzleResolvedOperator } from './operatorMap.js';
+type Args = {
+    adapter: DrizzleAdapter;
+    column: Column | SQL;
+    field: FlattenedField;
+    locale?: string;
+    originalOperator: Operator;
+    path: string;
+    resolvedOperator: DrizzleResolvedOperator;
+    value: unknown;
+};
+/**
+ * Builds the final, user-facing SQL comparison for one query leaf: applies every matching
+ * operand-transform handler in configuration order, then either calls the single matching
+ * replacement handler or falls back to `adapter.operators[resolvedOperator]`.
+ */
+export declare const buildOperatorConstraint: (args: Args) => SQL;
+export {};
+//# sourceMappingURL=buildOperatorConstraint.d.ts.map

package/dist/queries/buildOperatorConstraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildOperatorConstraint.d.ts","sourceRoot":"","sources":["../../src/queries/buildOperatorConstraint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIvD,OAAO,KAAK,EACV,cAAc,EAKf,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAE/D,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,MAAM,EAAE,MAAM,GAAG,GAAG,CAAA;IACpB,KAAK,EAAE,cAAc,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,gBAAgB,EAAE,QAAQ,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,EAAE,uBAAuB,CAAA;IACzC,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAsBD;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,SAAU,IAAI,KAAG,GAuDpD,CAAA"}

package/dist/queries/buildOperatorConstraint.js

@@ -0,0 +1,63 @@
+import { APIError } from 'payload';
+const isTransformHandler = (handler)=>typeof handler.transformOperands === 'function';
+const isReplacementHandler = (handler)=>typeof handler.build === 'function';
+const handlerMatches = (handler, args)=>{
+    if (!handler.operators.includes(args.resolvedOperator)) {
+        return false;
+    }
+    if (handler.fieldTypes && !handler.fieldTypes.includes(args.field.type)) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Builds the final, user-facing SQL comparison for one query leaf: applies every matching
+ * operand-transform handler in configuration order, then either calls the single matching
+ * replacement handler or falls back to `adapter.operators[resolvedOperator]`.
+ */ export const buildOperatorConstraint = (args)=>{
+    const { adapter, field, locale, originalOperator, path, resolvedOperator } = args;
+    const matchingHandlers = (adapter.operatorHandlers ?? []).filter((handler)=>handlerMatches(handler, args));
+    const context = {
+        adapter,
+        column: args.column,
+        field,
+        locale,
+        originalOperator,
+        path,
+        resolvedOperator,
+        storage: 'column',
+        value: args.value
+    };
+    for (const handler of matchingHandlers.filter(isTransformHandler)){
+        let result;
+        try {
+            result = handler.transformOperands({
+                ...context
+            });
+        } catch (error) {
+            throw new Error(`Operator handler "${handler.name}" threw while transforming operands for the "${resolvedOperator}" operator at path "${path}".`, {
+                cause: error
+            });
+        }
+        if (!result || typeof result !== 'object' || !('column' in result) || !('value' in result)) {
+            throw new APIError(`Operator handler "${handler.name}" returned an invalid operand transform for the "${resolvedOperator}" operator at path "${path}". Expected an object with "column" and "value" properties.`);
+        }
+        context.column = result.column;
+        context.value = result.value;
+    }
+    const replacementHandler = matchingHandlers.find(isReplacementHandler);
+    if (replacementHandler) {
+        try {
+            return replacementHandler.build({
+                ...context
+            });
+        } catch (error) {
+            throw new Error(`Operator handler "${replacementHandler.name}" threw while building the "${resolvedOperator}" comparison at path "${path}".`, {
+                cause: error
+            });
+        }
+    }
+    return adapter.operators[resolvedOperator](context.column, context.value);
+};
+
+//# sourceMappingURL=buildOperatorConstraint.js.map

package/dist/queries/buildOperatorConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/buildOperatorConstraint.ts"],"sourcesContent":["import type { Column, SQL } from 'drizzle-orm'\nimport type { FlattenedField, Operator } from 'payload'\n\nimport { APIError } from 'payload'\n\nimport type {\n  DrizzleAdapter,\n  DrizzleOperandTransformHandler,\n  DrizzleOperatorHandler,\n  DrizzleOperatorHandlerContext,\n  DrizzleOperatorReplacementHandler,\n} from '../types.js'\nimport type { DrizzleResolvedOperator } from './operatorMap.js'\n\ntype Args = {\n  adapter: DrizzleAdapter\n  column: Column | SQL\n  field: FlattenedField\n  locale?: string\n  originalOperator: Operator\n  path: string\n  resolvedOperator: DrizzleResolvedOperator\n  value: unknown\n}\n\nconst isTransformHandler = (\n  handler: DrizzleOperatorHandler,\n): handler is DrizzleOperandTransformHandler => typeof handler.transformOperands === 'function'\n\nconst isReplacementHandler = (\n  handler: DrizzleOperatorHandler,\n): handler is DrizzleOperatorReplacementHandler => typeof handler.build === 'function'\n\nconst handlerMatches = (handler: DrizzleOperatorHandler, args: Args): boolean => {\n  if (!handler.operators.includes(args.resolvedOperator)) {\n    return false\n  }\n\n  if (handler.fieldTypes && !handler.fieldTypes.includes(args.field.type)) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Builds the final, user-facing SQL comparison for one query leaf: applies every matching\n * operand-transform handler in configuration order, then either calls the single matching\n * replacement handler or falls back to `adapter.operators[resolvedOperator]`.\n */\nexport const buildOperatorConstraint = (args: Args): SQL => {\n  const { adapter, field, locale, originalOperator, path, resolvedOperator } = args\n\n  const matchingHandlers = (adapter.operatorHandlers ?? []).filter((handler) =>\n    handlerMatches(handler, args),\n  )\n\n  const context: DrizzleOperatorHandlerContext = {\n    adapter,\n    column: args.column,\n    field,\n    locale,\n    originalOperator,\n    path,\n    resolvedOperator,\n    storage: 'column',\n    value: args.value,\n  }\n\n  for (const handler of matchingHandlers.filter(isTransformHandler)) {\n    let result: { column: Column | SQL; value: unknown }\n\n    try {\n      result = handler.transformOperands({ ...context })\n    } catch (error) {\n      throw new Error(\n        `Operator handler \"${handler.name}\" threw while transforming operands for the \"${resolvedOperator}\" operator at path \"${path}\".`,\n        { cause: error },\n      )\n    }\n\n    if (!result || typeof result !== 'object' || !('column' in result) || !('value' in result)) {\n      throw new APIError(\n        `Operator handler \"${handler.name}\" returned an invalid operand transform for the \"${resolvedOperator}\" operator at path \"${path}\". Expected an object with \"column\" and \"value\" properties.`,\n      )\n    }\n\n    context.column = result.column\n    context.value = result.value\n  }\n\n  const replacementHandler = matchingHandlers.find(isReplacementHandler)\n\n  if (replacementHandler) {\n    try {\n      return replacementHandler.build({ ...context })\n    } catch (error) {\n      throw new Error(\n        `Operator handler \"${replacementHandler.name}\" threw while building the \"${resolvedOperator}\" comparison at path \"${path}\".`,\n        { cause: error },\n      )\n    }\n  }\n\n  return adapter.operators[resolvedOperator](context.column, context.value)\n}\n"],"names":["APIError","isTransformHandler","handler","transformOperands","isReplacementHandler","build","handlerMatches","args","operators","includes","resolvedOperator","fieldTypes","field","type","buildOperatorConstraint","adapter","locale","originalOperator","path","matchingHandlers","operatorHandlers","filter","context","column","storage","value","result","error","Error","name","cause","replacementHandler","find"],"mappings":"AAGA,SAASA,QAAQ,QAAQ,UAAS;AAsBlC,MAAMC,qBAAqB,CACzBC,UAC8C,OAAOA,QAAQC,iBAAiB,KAAK;AAErF,MAAMC,uBAAuB,CAC3BF,UACiD,OAAOA,QAAQG,KAAK,KAAK;AAE5E,MAAMC,iBAAiB,CAACJ,SAAiCK;IACvD,IAAI,CAACL,QAAQM,SAAS,CAACC,QAAQ,CAACF,KAAKG,gBAAgB,GAAG;QACtD,OAAO;IACT;IAEA,IAAIR,QAAQS,UAAU,IAAI,CAACT,QAAQS,UAAU,CAACF,QAAQ,CAACF,KAAKK,KAAK,CAACC,IAAI,GAAG;QACvE,OAAO;IACT;IAEA,OAAO;AACT;AAEA;;;;CAIC,GACD,OAAO,MAAMC,0BAA0B,CAACP;IACtC,MAAM,EAAEQ,OAAO,EAAEH,KAAK,EAAEI,MAAM,EAAEC,gBAAgB,EAAEC,IAAI,EAAER,gBAAgB,EAAE,GAAGH;IAE7E,MAAMY,mBAAmB,AAACJ,CAAAA,QAAQK,gBAAgB,IAAI,EAAE,AAAD,EAAGC,MAAM,CAAC,CAACnB,UAChEI,eAAeJ,SAASK;IAG1B,MAAMe,UAAyC;QAC7CP;QACAQ,QAAQhB,KAAKgB,MAAM;QACnBX;QACAI;QACAC;QACAC;QACAR;QACAc,SAAS;QACTC,OAAOlB,KAAKkB,KAAK;IACnB;IAEA,KAAK,MAAMvB,WAAWiB,iBAAiBE,MAAM,CAACpB,oBAAqB;QACjE,IAAIyB;QAEJ,IAAI;YACFA,SAASxB,QAAQC,iBAAiB,CAAC;gBAAE,GAAGmB,OAAO;YAAC;QAClD,EAAE,OAAOK,OAAO;YACd,MAAM,IAAIC,MACR,CAAC,kBAAkB,EAAE1B,QAAQ2B,IAAI,CAAC,6CAA6C,EAAEnB,iBAAiB,oBAAoB,EAAEQ,KAAK,EAAE,CAAC,EAChI;gBAAEY,OAAOH;YAAM;QAEnB;QAEA,IAAI,CAACD,UAAU,OAAOA,WAAW,YAAY,CAAE,CAAA,YAAYA,MAAK,KAAM,CAAE,CAAA,WAAWA,MAAK,GAAI;YAC1F,MAAM,IAAI1B,SACR,CAAC,kBAAkB,EAAEE,QAAQ2B,IAAI,CAAC,iDAAiD,EAAEnB,iBAAiB,oBAAoB,EAAEQ,KAAK,2DAA2D,CAAC;QAEjM;QAEAI,QAAQC,MAAM,GAAGG,OAAOH,MAAM;QAC9BD,QAAQG,KAAK,GAAGC,OAAOD,KAAK;IAC9B;IAEA,MAAMM,qBAAqBZ,iBAAiBa,IAAI,CAAC5B;IAEjD,IAAI2B,oBAAoB;QACtB,IAAI;YACF,OAAOA,mBAAmB1B,KAAK,CAAC;gBAAE,GAAGiB,OAAO;YAAC;QAC/C,EAAE,OAAOK,OAAO;YACd,MAAM,IAAIC,MACR,CAAC,kBAAkB,EAAEG,mBAAmBF,IAAI,CAAC,4BAA4B,EAAEnB,iBAAiB,sBAAsB,EAAEQ,KAAK,EAAE,CAAC,EAC5H;gBAAEY,OAAOH;YAAM;QAEnB;IACF;IAEA,OAAOZ,QAAQP,SAAS,CAACE,iBAAiB,CAACY,QAAQC,MAAM,EAAED,QAAQG,KAAK;AAC1E,EAAC"}

package/dist/queries/buildOperatorConstraint.spec.js

@@ -0,0 +1,348 @@
+import { sql } from 'drizzle-orm';
+import { describe, expect, it, vi } from 'vitest';
+import { buildOperatorConstraint } from './buildOperatorConstraint.js';
+const textField = {
+    name: 'title',
+    type: 'text'
+};
+const numberField = {
+    name: 'age',
+    type: 'number'
+};
+describe('buildOperatorConstraint', ()=>{
+    it('calls the default operator unchanged when no handlers are configured', ()=>{
+        const sentinel = sql`sentinel`;
+        const containsOperator = vi.fn().mockReturnValue(sentinel);
+        const adapter = {
+            operatorHandlers: [],
+            operators: {
+                contains: containsOperator
+            }
+        };
+        const column = 'col';
+        const result = buildOperatorConstraint({
+            adapter,
+            column,
+            field: textField,
+            originalOperator: 'contains',
+            path: 'title',
+            resolvedOperator: 'contains',
+            value: 'acido'
+        });
+        expect(containsOperator).toHaveBeenCalledWith(column, 'acido');
+        expect(result).toBe(sentinel);
+    });
+    it('applies operand-transform handlers in configuration order before the default operator runs', ()=>{
+        const calls = [];
+        const containsOperator = vi.fn(()=>sql`result`);
+        const handlerA = {
+            name: 'handler-a',
+            operators: [
+                'contains'
+            ],
+            transformOperands: ({ column, value })=>{
+                calls.push('a');
+                return {
+                    column: `${column}-a`,
+                    value: `${value}-a`
+                };
+            }
+        };
+        const handlerB = {
+            name: 'handler-b',
+            operators: [
+                'contains'
+            ],
+            transformOperands: ({ column, value })=>{
+                calls.push('b');
+                return {
+                    column: `${column}-b`,
+                    value: `${value}-b`
+                };
+            }
+        };
+        const adapter = {
+            operatorHandlers: [
+                handlerA,
+                handlerB
+            ],
+            operators: {
+                contains: containsOperator
+            }
+        };
+        buildOperatorConstraint({
+            adapter,
+            column: 'base-column',
+            field: textField,
+            originalOperator: 'contains',
+            path: 'title',
+            resolvedOperator: 'contains',
+            value: 'acido'
+        });
+        expect(calls).toEqual([
+            'a',
+            'b'
+        ]);
+        expect(containsOperator).toHaveBeenCalledWith('base-column-a-b', 'acido-a-b');
+    });
+    it('skips a handler whose operators list excludes the resolved operator', ()=>{
+        const transformOperands = vi.fn(({ column, value })=>({
+                column,
+                value
+            }));
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'like-only',
+                    operators: [
+                        'like'
+                    ],
+                    transformOperands
+                }
+            ],
+            operators: {
+                contains: vi.fn(()=>sql`result`)
+            }
+        };
+        buildOperatorConstraint({
+            adapter,
+            column: 'col',
+            field: textField,
+            originalOperator: 'contains',
+            path: 'title',
+            resolvedOperator: 'contains',
+            value: 'acido'
+        });
+        expect(transformOperands).not.toHaveBeenCalled();
+    });
+    it("skips a handler whose fieldTypes excludes the field's type even when operators matches", ()=>{
+        const transformOperands = vi.fn(({ column, value })=>({
+                column,
+                value
+            }));
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'text-only',
+                    operators: [
+                        'contains'
+                    ],
+                    fieldTypes: [
+                        'text'
+                    ],
+                    transformOperands
+                }
+            ],
+            operators: {
+                contains: vi.fn(()=>sql`result`)
+            }
+        };
+        buildOperatorConstraint({
+            adapter,
+            column: 'col',
+            field: numberField,
+            originalOperator: 'contains',
+            path: 'age',
+            resolvedOperator: 'contains',
+            value: 5
+        });
+        expect(transformOperands).not.toHaveBeenCalled();
+    });
+    it('runs a handler with no fieldTypes for every field type', ()=>{
+        const transformOperands = vi.fn(({ column, value })=>({
+                column,
+                value
+            }));
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'universal',
+                    operators: [
+                        'contains'
+                    ],
+                    transformOperands
+                }
+            ],
+            operators: {
+                contains: vi.fn(()=>sql`result`)
+            }
+        };
+        buildOperatorConstraint({
+            adapter,
+            column: 'col',
+            field: numberField,
+            originalOperator: 'contains',
+            path: 'age',
+            resolvedOperator: 'contains',
+            value: 5
+        });
+        expect(transformOperands).toHaveBeenCalled();
+    });
+    it('gives a single matching replacement handler the operands after every transform has run, and uses its result instead of the default operator', ()=>{
+        const containsOperator = vi.fn();
+        const sentinel = sql`replacement`;
+        const build = vi.fn().mockReturnValue(sentinel);
+        const transformOperands = vi.fn(({ column, value })=>({
+                column: `${column}-t`,
+                value: `${value}-t`
+            }));
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'transform',
+                    operators: [
+                        'contains'
+                    ],
+                    transformOperands
+                },
+                {
+                    name: 'replace',
+                    operators: [
+                        'contains'
+                    ],
+                    build
+                }
+            ],
+            operators: {
+                contains: containsOperator
+            }
+        };
+        const result = buildOperatorConstraint({
+            adapter,
+            column: 'col',
+            field: textField,
+            originalOperator: 'contains',
+            path: 'title',
+            resolvedOperator: 'contains',
+            value: 'acido'
+        });
+        expect(build).toHaveBeenCalledWith(expect.objectContaining({
+            column: 'col-t',
+            value: 'acido-t'
+        }));
+        expect(containsOperator).not.toHaveBeenCalled();
+        expect(result).toBe(sentinel);
+    });
+    it('passes originalOperator, resolvedOperator, field, path, and locale to handlers', ()=>{
+        let capturedContext;
+        const transformOperands = vi.fn((context)=>{
+            capturedContext = context;
+            return {
+                column: context.column,
+                value: context.value
+            };
+        });
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'observe',
+                    operators: [
+                        'like'
+                    ],
+                    transformOperands
+                }
+            ],
+            operators: {
+                like: vi.fn(()=>sql`result`)
+            }
+        };
+        buildOperatorConstraint({
+            adapter,
+            column: 'col',
+            field: textField,
+            locale: 'es',
+            originalOperator: 'like',
+            path: 'title',
+            resolvedOperator: 'like',
+            value: '%nino%'
+        });
+        expect(capturedContext).toMatchObject({
+            field: textField,
+            locale: 'es',
+            originalOperator: 'like',
+            path: 'title',
+            resolvedOperator: 'like'
+        });
+    });
+    it('wraps a handler error with the handler name, path, and resolved operator, retaining the original error as the cause', ()=>{
+        const originalError = new Error('boom');
+        const transformOperands = vi.fn(()=>{
+            throw originalError;
+        });
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'explode',
+                    operators: [
+                        'contains'
+                    ],
+                    transformOperands
+                }
+            ],
+            operators: {
+                contains: vi.fn()
+            }
+        };
+        let thrown;
+        try {
+            buildOperatorConstraint({
+                adapter,
+                column: 'col',
+                field: textField,
+                originalOperator: 'contains',
+                path: 'title',
+                resolvedOperator: 'contains',
+                value: 'acido'
+            });
+        } catch (error) {
+            thrown = error;
+        }
+        expect(thrown).toBeInstanceOf(Error);
+        const error = thrown;
+        expect(error.message).toContain('explode');
+        expect(error.message).toContain('title');
+        expect(error.message).toContain('contains');
+        expect(error.cause).toBe(originalError);
+    });
+    it('throws a configuration error when a transform handler returns operands missing column or value, before any default operator or replacement runs', ()=>{
+        const transformOperands = vi.fn().mockReturnValue({
+            column: 'only-column'
+        });
+        const containsOperator = vi.fn();
+        const build = vi.fn();
+        const adapter = {
+            operatorHandlers: [
+                {
+                    name: 'broken',
+                    operators: [
+                        'contains'
+                    ],
+                    transformOperands
+                },
+                {
+                    name: 'replace',
+                    operators: [
+                        'contains'
+                    ],
+                    build
+                }
+            ],
+            operators: {
+                contains: containsOperator
+            }
+        };
+        expect(()=>buildOperatorConstraint({
+                adapter,
+                column: 'col',
+                field: textField,
+                originalOperator: 'contains',
+                path: 'title',
+                resolvedOperator: 'contains',
+                value: 'acido'
+            })).toThrow(/broken/);
+        expect(containsOperator).not.toHaveBeenCalled();
+        expect(build).not.toHaveBeenCalled();
+    });
+});
+
+//# sourceMappingURL=buildOperatorConstraint.spec.js.map

package/dist/queries/buildOperatorConstraint.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/buildOperatorConstraint.spec.ts"],"sourcesContent":["import type { Column } from 'drizzle-orm'\nimport type { FlattenedField } from 'payload'\n\nimport { sql } from 'drizzle-orm'\nimport { describe, expect, it, vi } from 'vitest'\n\nimport type { DrizzleAdapter, DrizzleOperandTransformHandler } from '../types.js'\n\nimport { buildOperatorConstraint } from './buildOperatorConstraint.js'\n\nconst textField = { name: 'title', type: 'text' } as unknown as FlattenedField\nconst numberField = { name: 'age', type: 'number' } as unknown as FlattenedField\n\ndescribe('buildOperatorConstraint', () => {\n  it('calls the default operator unchanged when no handlers are configured', () => {\n    const sentinel = sql`sentinel`\n    const containsOperator = vi.fn().mockReturnValue(sentinel)\n    const adapter = {\n      operatorHandlers: [],\n      operators: { contains: containsOperator },\n    } as unknown as DrizzleAdapter\n    const column = 'col' as unknown as Column\n\n    const result = buildOperatorConstraint({\n      adapter,\n      column,\n      field: textField,\n      originalOperator: 'contains',\n      path: 'title',\n      resolvedOperator: 'contains',\n      value: 'acido',\n    })\n\n    expect(containsOperator).toHaveBeenCalledWith(column, 'acido')\n    expect(result).toBe(sentinel)\n  })\n\n  it('applies operand-transform handlers in configuration order before the default operator runs', () => {\n    const calls: string[] = []\n    const containsOperator = vi.fn(() => sql`result`)\n\n    const handlerA: DrizzleOperandTransformHandler = {\n      name: 'handler-a',\n      operators: ['contains'],\n      transformOperands: ({ column, value }) => {\n        calls.push('a')\n        return { column: `${column}-a` as unknown as Column, value: `${value}-a` }\n      },\n    }\n    const handlerB: DrizzleOperandTransformHandler = {\n      name: 'handler-b',\n      operators: ['contains'],\n      transformOperands: ({ column, value }) => {\n        calls.push('b')\n        return { column: `${column}-b` as unknown as Column, value: `${value}-b` }\n      },\n    }\n\n    const adapter = {\n      operatorHandlers: [handlerA, handlerB],\n      operators: { contains: containsOperator },\n    } as unknown as DrizzleAdapter\n\n    buildOperatorConstraint({\n      adapter,\n      column: 'base-column' as unknown as Column,\n      field: textField,\n      originalOperator: 'contains',\n      path: 'title',\n      resolvedOperator: 'contains',\n      value: 'acido',\n    })\n\n    expect(calls).toEqual(['a', 'b'])\n    expect(containsOperator).toHaveBeenCalledWith('base-column-a-b', 'acido-a-b')\n  })\n\n  it('skips a handler whose operators list excludes the resolved operator', () => {\n    const transformOperands = vi.fn(({ column, value }) => ({ column, value }))\n    const adapter = {\n      operatorHandlers: [{ name: 'like-only', operators: ['like'], transformOperands }],\n      operators: { contains: vi.fn(() => sql`result`) },\n    } as unknown as DrizzleAdapter\n\n    buildOperatorConstraint({\n      adapter,\n      column: 'col' as unknown as Column,\n      field: textField,\n      originalOperator: 'contains',\n      path: 'title',\n      resolvedOperator: 'contains',\n      value: 'acido',\n    })\n\n    expect(transformOperands).not.toHaveBeenCalled()\n  })\n\n  it(\"skips a handler whose fieldTypes excludes the field's type even when operators matches\", () => {\n    const transformOperands = vi.fn(({ column, value }) => ({ column, value }))\n    const adapter = {\n      operatorHandlers: [\n        { name: 'text-only', operators: ['contains'], fieldTypes: ['text'], transformOperands },\n      ],\n      operators: { contains: vi.fn(() => sql`result`) },\n    } as unknown as DrizzleAdapter\n\n    buildOperatorConstraint({\n      adapter,\n      column: 'col' as unknown as Column,\n      field: numberField,\n      originalOperator: 'contains',\n      path: 'age',\n      resolvedOperator: 'contains',\n      value: 5,\n    })\n\n    expect(transformOperands).not.toHaveBeenCalled()\n  })\n\n  it('runs a handler with no fieldTypes for every field type', () => {\n    const transformOperands = vi.fn(({ column, value }) => ({ column, value }))\n    const adapter = {\n      operatorHandlers: [{ name: 'universal', operators: ['contains'], transformOperands }],\n      operators: { contains: vi.fn(() => sql`result`) },\n    } as unknown as DrizzleAdapter\n\n    buildOperatorConstraint({\n      adapter,\n      column: 'col' as unknown as Column,\n      field: numberField,\n      originalOperator: 'contains',\n      path: 'age',\n      resolvedOperator: 'contains',\n      value: 5,\n    })\n\n    expect(transformOperands).toHaveBeenCalled()\n  })\n\n  it('gives a single matching replacement handler the operands after every transform has run, and uses its result instead of the default operator', () => {\n    const containsOperator = vi.fn()\n    const sentinel = sql`replacement`\n    const build = vi.fn().mockReturnValue(sentinel)\n    const transformOperands = vi.fn(({ column, value }) => ({\n      column: `${column}-t` as unknown as Column,\n      value: `${value}-t`,\n    }))\n\n    const adapter = {\n      operatorHandlers: [\n        { name: 'transform', operators: ['contains'], transformOperands },\n        { name: 'replace', operators: ['contains'], build },\n      ],\n      operators: { contains: containsOperator },\n    } as unknown as DrizzleAdapter\n\n    const result = buildOperatorConstraint({\n      adapter,\n      column: 'col' as unknown as Column,\n      field: textField,\n      originalOperator: 'contains',\n      path: 'title',\n      resolvedOperator: 'contains',\n      value: 'acido',\n    })\n\n    expect(build).toHaveBeenCalledWith(\n      expect.objectContaining({ column: 'col-t', value: 'acido-t' }),\n    )\n    expect(containsOperator).not.toHaveBeenCalled()\n    expect(result).toBe(sentinel)\n  })\n\n  it('passes originalOperator, resolvedOperator, field, path, and locale to handlers', () => {\n    let capturedContext: any\n    const transformOperands = vi.fn((context) => {\n      capturedContext = context\n      return { column: context.column, value: context.value }\n    })\n\n    const adapter = {\n      operatorHandlers: [{ name: 'observe', operators: ['like'], transformOperands }],\n      operators: { like: vi.fn(() => sql`result`) },\n    } as unknown as DrizzleAdapter\n\n    buildOperatorConstraint({\n      adapter,\n      column: 'col' as unknown as Column,\n      field: textField,\n      locale: 'es',\n      originalOperator: 'like',\n      path: 'title',\n      resolvedOperator: 'like',\n      value: '%nino%',\n    })\n\n    expect(capturedContext).toMatchObject({\n      field: textField,\n      locale: 'es',\n      originalOperator: 'like',\n      path: 'title',\n      resolvedOperator: 'like',\n    })\n  })\n\n  it('wraps a handler error with the handler name, path, and resolved operator, retaining the original error as the cause', () => {\n    const originalError = new Error('boom')\n    const transformOperands = vi.fn(() => {\n      throw originalError\n    })\n\n    const adapter = {\n      operatorHandlers: [{ name: 'explode', operators: ['contains'], transformOperands }],\n      operators: { contains: vi.fn() },\n    } as unknown as DrizzleAdapter\n\n    let thrown: unknown\n    try {\n      buildOperatorConstraint({\n        adapter,\n        column: 'col' as unknown as Column,\n        field: textField,\n        originalOperator: 'contains',\n        path: 'title',\n        resolvedOperator: 'contains',\n        value: 'acido',\n      })\n    } catch (error) {\n      thrown = error\n    }\n\n    expect(thrown).toBeInstanceOf(Error)\n    const error = thrown as Error\n    expect(error.message).toContain('explode')\n    expect(error.message).toContain('title')\n    expect(error.message).toContain('contains')\n    expect(error.cause).toBe(originalError)\n  })\n\n  it('throws a configuration error when a transform handler returns operands missing column or value, before any default operator or replacement runs', () => {\n    const transformOperands = vi.fn().mockReturnValue({ column: 'only-column' })\n    const containsOperator = vi.fn()\n    const build = vi.fn()\n\n    const adapter = {\n      operatorHandlers: [\n        { name: 'broken', operators: ['contains'], transformOperands },\n        { name: 'replace', operators: ['contains'], build },\n      ],\n      operators: { contains: containsOperator },\n    } as unknown as DrizzleAdapter\n\n    expect(() =>\n      buildOperatorConstraint({\n        adapter,\n        column: 'col' as unknown as Column,\n        field: textField,\n        originalOperator: 'contains',\n        path: 'title',\n        resolvedOperator: 'contains',\n        value: 'acido',\n      }),\n    ).toThrow(/broken/)\n\n    expect(containsOperator).not.toHaveBeenCalled()\n    expect(build).not.toHaveBeenCalled()\n  })\n})\n"],"names":["sql","describe","expect","it","vi","buildOperatorConstraint","textField","name","type","numberField","sentinel","containsOperator","fn","mockReturnValue","adapter","operatorHandlers","operators","contains","column","result","field","originalOperator","path","resolvedOperator","value","toHaveBeenCalledWith","toBe","calls","handlerA","transformOperands","push","handlerB","toEqual","not","toHaveBeenCalled","fieldTypes","build","objectContaining","capturedContext","context","like","locale","toMatchObject","originalError","Error","thrown","error","toBeInstanceOf","message","toContain","cause","toThrow"],"mappings":"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"}

package/dist/queries/operatorMap.d.ts

@@ -1,6 +1,10 @@
 import { type Column, type SQL } from 'drizzle-orm';
-type OperatorKeys = 'and' | 'contains' | 'equals' | 'exists' | 'greater_than' | 'greater_than_equal' | 'in' | 'isNull' | 'less_than' | 'less_than_equal' | 'like' | 'not_equals' | 'not_in' | 'not_like' | 'or';
-export type Operators = Record<OperatorKeys, (column: Column, value: unknown) => SQL>;
+export type OperatorKeys = 'and' | 'contains' | 'equals' | 'exists' | 'greater_than' | 'greater_than_equal' | 'in' | 'isNull' | 'less_than' | 'less_than_equal' | 'like' | 'not_equals' | 'not_in' | 'not_like' | 'or';
+/**
+ * The subset of operator keys that represent an actual user-facing comparison operator,
+ * excluding the `and`/`or` boolean combinators.
+ */
+export type DrizzleResolvedOperator = Exclude<OperatorKeys, 'and' | 'or'>;
+export type Operators = Record<OperatorKeys, (column: Column | SQL, value: unknown) => SQL>;
 export declare const operatorMap: Operators;
-export {};
 //# sourceMappingURL=operatorMap.d.ts.map

package/dist/queries/operatorMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operatorMap.d.ts","sourceRoot":"","sources":["../../src/queries/operatorMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAcX,KAAK,GAAG,EACT,MAAM,aAAa,CAAA;AAEpB,KAAK,YAAY,GACb,KAAK,GACL,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,cAAc,GACd,oBAAoB,GACpB,IAAI,GACJ,QAAQ,GACR,WAAW,GACX,iBAAiB,GACjB,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,IAAI,CAAA;AAER,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,GAAG,CAAC,CAAA;AAErF,eAAO,MAAM,WAAW,EAAE,SAkBzB,CAAA"}
+{"version":3,"file":"operatorMap.d.ts","sourceRoot":"","sources":["../../src/queries/operatorMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAcX,KAAK,GAAG,EACT,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,YAAY,GACpB,KAAK,GACL,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,cAAc,GACd,oBAAoB,GACpB,IAAI,GACJ,QAAQ,GACR,WAAW,GACX,iBAAiB,GACjB,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,IAAI,CAAA;AAER;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,YAAY,EAAE,KAAK,GAAG,IAAI,CAAC,CAAA;AAEzE,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,KAAK,EAAE,OAAO,KAAK,GAAG,CAAC,CAAA;AAE3F,eAAO,MAAM,WAAW,EAAE,SAkBzB,CAAA"}

package/dist/queries/operatorMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/queries/operatorMap.ts"],"sourcesContent":["import {\n  and,\n  type Column,\n  eq,\n  gt,\n  gte,\n  ilike,\n  inArray,\n  isNotNull,\n  isNull,\n  lt,\n  lte,\n  ne,\n  notIlike,\n  notInArray,\n  or,\n  type SQL,\n} from 'drizzle-orm'\n\ntype OperatorKeys =\n  | 'and'\n  | 'contains'\n  | 'equals'\n  | 'exists'\n  | 'greater_than'\n  | 'greater_than_equal'\n  | 'in'\n  | 'isNull'\n  | 'less_than'\n  | 'less_than_equal'\n  | 'like'\n  | 'not_equals'\n  | 'not_in'\n  | 'not_like'\n  | 'or'\n\nexport type Operators = Record<OperatorKeys, (column: Column, value: unknown) => SQL>\n\nexport const operatorMap: Operators = {\n  and,\n  contains: ilike,\n  equals: eq,\n  exists: isNotNull,\n  greater_than: gt,\n  greater_than_equal: gte,\n  in: inArray,\n  isNull, // handles exists: false\n  less_than: lt,\n  less_than_equal: lte,\n  like: ilike,\n  not_equals: ne,\n  not_like: notIlike,\n  // TODO: support this\n  // all: all,\n  not_in: notInArray,\n  or,\n}\n"],"names":["and","eq","gt","gte","ilike","inArray","isNotNull","isNull","lt","lte","ne","notIlike","notInArray","or","operatorMap","contains","equals","exists","greater_than","greater_than_equal","in","less_than","less_than_equal","like","not_equals","not_like","not_in"],"mappings":"AAAA,SACEA,GAAG,EAEHC,EAAE,EACFC,EAAE,EACFC,GAAG,EACHC,KAAK,EACLC,OAAO,EACPC,SAAS,EACTC,MAAM,EACNC,EAAE,EACFC,GAAG,EACHC,EAAE,EACFC,QAAQ,EACRC,UAAU,EACVC,EAAE,QAEG,cAAa;AAqBpB,OAAO,MAAMC,cAAyB;IACpCd;IACAe,UAAUX;IACVY,QAAQf;IACRgB,QAAQX;IACRY,cAAchB;IACdiB,oBAAoBhB;IACpBiB,IAAIf;IACJE;IACAc,WAAWb;IACXc,iBAAiBb;IACjBc,MAAMnB;IACNoB,YAAYd;IACZe,UAAUd;IACV,qBAAqB;IACrB,YAAY;IACZe,QAAQd;IACRC;AACF,EAAC"}
+{"version":3,"sources":["../../src/queries/operatorMap.ts"],"sourcesContent":["import {\n  and,\n  type Column,\n  eq,\n  gt,\n  gte,\n  ilike,\n  inArray,\n  isNotNull,\n  isNull,\n  lt,\n  lte,\n  ne,\n  notIlike,\n  notInArray,\n  or,\n  type SQL,\n} from 'drizzle-orm'\n\nexport type OperatorKeys =\n  | 'and'\n  | 'contains'\n  | 'equals'\n  | 'exists'\n  | 'greater_than'\n  | 'greater_than_equal'\n  | 'in'\n  | 'isNull'\n  | 'less_than'\n  | 'less_than_equal'\n  | 'like'\n  | 'not_equals'\n  | 'not_in'\n  | 'not_like'\n  | 'or'\n\n/**\n * The subset of operator keys that represent an actual user-facing comparison operator,\n * excluding the `and`/`or` boolean combinators.\n */\nexport type DrizzleResolvedOperator = Exclude<OperatorKeys, 'and' | 'or'>\n\nexport type Operators = Record<OperatorKeys, (column: Column | SQL, value: unknown) => SQL>\n\nexport const operatorMap: Operators = {\n  and,\n  contains: ilike,\n  equals: eq,\n  exists: isNotNull,\n  greater_than: gt,\n  greater_than_equal: gte,\n  in: inArray,\n  isNull, // handles exists: false\n  less_than: lt,\n  less_than_equal: lte,\n  like: ilike,\n  not_equals: ne,\n  not_like: notIlike,\n  // TODO: support this\n  // all: all,\n  not_in: notInArray,\n  or,\n}\n"],"names":["and","eq","gt","gte","ilike","inArray","isNotNull","isNull","lt","lte","ne","notIlike","notInArray","or","operatorMap","contains","equals","exists","greater_than","greater_than_equal","in","less_than","less_than_equal","like","not_equals","not_like","not_in"],"mappings":"AAAA,SACEA,GAAG,EAEHC,EAAE,EACFC,EAAE,EACFC,GAAG,EACHC,KAAK,EACLC,OAAO,EACPC,SAAS,EACTC,MAAM,EACNC,EAAE,EACFC,GAAG,EACHC,EAAE,EACFC,QAAQ,EACRC,UAAU,EACVC,EAAE,QAEG,cAAa;AA2BpB,OAAO,MAAMC,cAAyB;IACpCd;IACAe,UAAUX;IACVY,QAAQf;IACRgB,QAAQX;IACRY,cAAchB;IACdiB,oBAAoBhB;IACpBiB,IAAIf;IACJE;IACAc,WAAWb;IACXc,iBAAiBb;IACjBc,MAAMnB;IACNoB,YAAYd;IACZe,UAAUd;IACV,qBAAqB;IACrB,YAAY;IACZe,QAAQd;IACRC;AACF,EAAC"}

package/dist/queries/parseParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseParams.d.ts","sourceRoot":"","sources":["../../src/queries/parseParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAY,IAAI,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAOpE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAU5D,MAAM,MAAM,YAAY,GAAG;IAAE,OAAO,CAAC,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAA;AAExD,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,UAAU,CAAC,EAAE,KAAK,CAAA;IAClB,OAAO,EAAE,YAAY,CAAA;IACrB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,KAAK,EAAE,qBAAqB,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iBAAiB,EAAE,OAAO,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3C,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,UAAU,EACV,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,KAAK,GACN,EAAE,IAAI,GAAG,GAAG,CA8bZ"}
+{"version":3,"file":"parseParams.d.ts","sourceRoot":"","sources":["../../src/queries/parseParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAY,IAAI,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAOpE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAY5D,MAAM,MAAM,YAAY,GAAG;IAAE,OAAO,CAAC,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAA;AAExD,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,UAAU,CAAC,EAAE,KAAK,CAAA;IAClB,OAAO,EAAE,YAAY,CAAA;IACrB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,KAAK,EAAE,qBAAqB,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iBAAiB,EAAE,OAAO,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3C,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,KAAK,CAAA;CACb,CAAA;AAED,wBAAgB,WAAW,CAAC,EAC1B,OAAO,EACP,UAAU,EACV,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,KAAK,GACN,EAAE,IAAI,GAAG,GAAG,CAweZ"}

package/dist/queries/parseParams.js

@@ -1,4 +1,4 @@
-import { and, getTableName, isNotNull, isNull, ne, notInArray, or, sql } from 'drizzle-orm';
+import { and, getTableName, isNotNull, isNull, notInArray, or, sql } from 'drizzle-orm';
 import { PgUUID } from 'drizzle-orm/pg-core';
 import { APIError, QueryError } from 'payload';
 import { validOperatorSet } from 'payload/shared';
@@ -7,6 +7,7 @@ import { getNameFromDrizzleTable } from '../utilities/getNameFromDrizzleTable.js
 import { isValidStringID } from '../utilities/isValidStringID.js';
 import { DistinctSymbol } from '../utilities/rawConstraint.js';
 import { buildAndOrConditions } from './buildAndOrConditions.js';
+import { buildOperatorConstraint } from './buildOperatorConstraint.js';
 import { getTableColumnFromPath } from './getTableColumnFromPath.js';
 import { sanitizeQueryValue } from './sanitizeQueryValue.js';
 export function parseParams({ adapter, aliasTable, context, fields, joins, locale, parentIsLocalized, selectFields, selectLocale, tableName, where }) {
@@ -49,6 +50,7 @@ export function parseParams({ adapter, aliasTable, context, fields, joins, local
                         for (let operator of Object.keys(pathOperators)){
                             if (validOperatorSet.has(operator)) {
                                 const val = where[relationOrPath][operator];
+                                const originalOperator = operator;
                                 const { columnName, columns, constraints: queryConstraints, field, getNotNullColumnByValue, pathSegments, rawColumn, table } = getTableColumnFromPath({
                                     adapter,
                                     aliasTable,
@@ -181,7 +183,16 @@ export function parseParams({ adapter, aliasTable, context, fields, joins, local
                                     operator = 'equals';
                                 }
                                 if (operator === 'like') {
-                                    constraints.push(and(...val.split(' ').map((word)=>adapter.operators.like(table[columnName], `%${word}%`))));
+                                    constraints.push(and(...val.split(' ').map((word)=>buildOperatorConstraint({
+                                            adapter,
+                                            column: table[columnName],
+                                            field,
+                                            locale,
+                                            originalOperator,
+                                            path: relationOrPath,
+                                            resolvedOperator: 'like',
+                                            value: `%${word}%`
+                                        }))));
                                     break;
                                 }
                                 const sanitizedQueryValue = sanitizeQueryValue({
@@ -219,11 +230,29 @@ export function parseParams({ adapter, aliasTable, context, fields, joins, local
                                     ].includes(operator)) {
                                         wrapOperator = and;
                                     }
-                                    constraints.push(wrapOperator(...queryColumns.map(({ rawColumn, value })=>adapter.operators[queryOperator](rawColumn, value))));
+                                    constraints.push(wrapOperator(...queryColumns.map(({ rawColumn, value })=>buildOperatorConstraint({
+                                            adapter,
+                                            column: rawColumn,
+                                            field,
+                                            locale,
+                                            originalOperator,
+                                            path: relationOrPath,
+                                            resolvedOperator: queryOperator,
+                                            value
+                                        }))));
                                     break;
                                 }
                                 if (queryOperator === 'not_equals' && queryValue !== null) {
-                                    constraints.push(or(isNull(resolvedColumn), /* eslint-disable @typescript-eslint/no-explicit-any */ ne(resolvedColumn, queryValue)));
+                                    constraints.push(or(isNull(resolvedColumn), buildOperatorConstraint({
+                                        adapter,
+                                        column: resolvedColumn,
+                                        field,
+                                        locale,
+                                        originalOperator,
+                                        path: relationOrPath,
+                                        resolvedOperator: 'not_equals',
+                                        value: queryValue
+                                    })));
                                     break;
                                 }
                                 if ((field.type === 'relationship' || field.type === 'upload') && Array.isArray(queryValue) && queryOperator === 'not_in') {
@@ -287,7 +316,16 @@ export function parseParams({ adapter, aliasTable, context, fields, joins, local
                                     'text'
                                 ].includes(field.type)) {
                                     // Create OR conditions for each value in the array
-                                    orConditions.push(...queryValue.map((val)=>adapter.operators[queryOperator](resolvedColumn, val)));
+                                    orConditions.push(...queryValue.map((val)=>buildOperatorConstraint({
+                                            adapter,
+                                            column: resolvedColumn,
+                                            field,
+                                            locale,
+                                            originalOperator,
+                                            path: relationOrPath,
+                                            resolvedOperator: queryOperator,
+                                            value: val
+                                        })));
                                     // Set constraint to combine all OR conditions
                                     const constraint = orConditions.length > 0 ? or(...orConditions) : undefined;
                                     if (constraint) {
@@ -295,7 +333,16 @@ export function parseParams({ adapter, aliasTable, context, fields, joins, local
                                     }
                                     break;
                                 }
-                                let constraint = adapter.operators[queryOperator](resolvedColumn, resolvedQueryValue);
+                                let constraint = buildOperatorConstraint({
+                                    adapter,
+                                    column: resolvedColumn,
+                                    field,
+                                    locale,
+                                    originalOperator,
+                                    path: relationOrPath,
+                                    resolvedOperator: queryOperator,
+                                    value: resolvedQueryValue
+                                });
                                 if (adapter.limitedBoundParameters && (operator === 'in' || operator === 'not_in') && relationOrPath === 'id' && Array.isArray(queryValue)) {
                                     let isInvalid = false;
                                     for (const val of queryValue){