@payloadcms/drizzle 4.0.0-internal.b8e7c89 → 4.0.0-internal.bf4bcce

package/dist/queries/buildOperatorConstraint.spec.js

@@ -1,348 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/validateOperatorHandlers.spec.js

@@ -1,142 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateOperatorHandlers } from './validateOperatorHandlers.js';
-const transformHandler = (overrides = {})=>({
-        name: 'transform',
-        operators: [
-            'contains'
-        ],
-        transformOperands: ({ column, value })=>({
-                column,
-                value
-            }),
-        ...overrides
-    });
-const replacementHandler = (overrides = {})=>({
-        name: 'replace',
-        operators: [
-            'contains'
-        ],
-        build: ()=>null,
-        ...overrides
-    });
-describe('validateOperatorHandlers', ()=>{
-    it('does not throw when zero handlers are configured', ()=>{
-        expect(()=>validateOperatorHandlers([])).not.toThrow();
-    });
-    it('does not throw for any number of non-conflicting operand-transform handlers', ()=>{
-        expect(()=>validateOperatorHandlers([
-                transformHandler({
-                    name: 'a'
-                }),
-                transformHandler({
-                    name: 'b'
-                }),
-                transformHandler({
-                    name: 'c'
-                })
-            ])).not.toThrow();
-    });
-    it('throws when two build handlers list the same resolved operator, naming both handlers and the operator', ()=>{
-        expect(()=>validateOperatorHandlers([
-                replacementHandler({
-                    name: 'handler-a',
-                    operators: [
-                        'contains'
-                    ]
-                }),
-                replacementHandler({
-                    name: 'handler-b',
-                    operators: [
-                        'contains'
-                    ]
-                })
-            ])).toThrow(/handler-a/);
-        expect(()=>validateOperatorHandlers([
-                replacementHandler({
-                    name: 'handler-a',
-                    operators: [
-                        'contains'
-                    ]
-                }),
-                replacementHandler({
-                    name: 'handler-b',
-                    operators: [
-                        'contains'
-                    ]
-                })
-            ])).toThrow(/handler-b/);
-        expect(()=>validateOperatorHandlers([
-                replacementHandler({
-                    name: 'handler-a',
-                    operators: [
-                        'contains'
-                    ]
-                }),
-                replacementHandler({
-                    name: 'handler-b',
-                    operators: [
-                        'contains'
-                    ]
-                })
-            ])).toThrow(/contains/);
-    });
-    it('does not throw when two build handlers target the same operator but declare disjoint fieldTypes', ()=>{
-        expect(()=>validateOperatorHandlers([
-                replacementHandler({
-                    name: 'text',
-                    operators: [
-                        'contains'
-                    ],
-                    fieldTypes: [
-                        'text'
-                    ]
-                }),
-                replacementHandler({
-                    name: 'number',
-                    operators: [
-                        'contains'
-                    ],
-                    fieldTypes: [
-                        'number'
-                    ]
-                })
-            ])).not.toThrow();
-    });
-    it('throws when two build handlers target the same operator and at least one declares no fieldTypes', ()=>{
-        expect(()=>validateOperatorHandlers([
-                replacementHandler({
-                    name: 'unrestricted',
-                    operators: [
-                        'contains'
-                    ]
-                }),
-                replacementHandler({
-                    name: 'text',
-                    operators: [
-                        'contains'
-                    ],
-                    fieldTypes: [
-                        'text'
-                    ]
-                })
-            ])).toThrow();
-    });
-    it('throws when a handler object defines both build and transformOperands', ()=>{
-        const malformed = {
-            name: 'malformed',
-            operators: [
-                'contains'
-            ],
-            build: ()=>null,
-            transformOperands: ({ column, value })=>({
-                    column,
-                    value
-                })
-        };
-        expect(()=>validateOperatorHandlers([
-                malformed
-            ])).toThrow(/malformed/);
-    });
-});
-
-//# sourceMappingURL=validateOperatorHandlers.spec.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/queries/validateOperatorHandlers.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport type { DrizzleOperatorHandler } from '../types.js'\n\nimport { validateOperatorHandlers } from './validateOperatorHandlers.js'\n\nconst transformHandler = (\n  overrides: Partial<DrizzleOperatorHandler> = {},\n): DrizzleOperatorHandler =>\n  ({\n    name: 'transform',\n    operators: ['contains'],\n    transformOperands: ({ column, value }) => ({ column, value }),\n    ...overrides,\n  }) as DrizzleOperatorHandler\n\nconst replacementHandler = (\n  overrides: Partial<DrizzleOperatorHandler> = {},\n): DrizzleOperatorHandler =>\n  ({\n    name: 'replace',\n    operators: ['contains'],\n    build: () => null as any,\n    ...overrides,\n  }) as DrizzleOperatorHandler\n\ndescribe('validateOperatorHandlers', () => {\n  it('does not throw when zero handlers are configured', () => {\n    expect(() => validateOperatorHandlers([])).not.toThrow()\n  })\n\n  it('does not throw for any number of non-conflicting operand-transform handlers', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        transformHandler({ name: 'a' }),\n        transformHandler({ name: 'b' }),\n        transformHandler({ name: 'c' }),\n      ]),\n    ).not.toThrow()\n  })\n\n  it('throws when two build handlers list the same resolved operator, naming both handlers and the operator', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'handler-a', operators: ['contains'] }),\n        replacementHandler({ name: 'handler-b', operators: ['contains'] }),\n      ]),\n    ).toThrow(/handler-a/)\n\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'handler-a', operators: ['contains'] }),\n        replacementHandler({ name: 'handler-b', operators: ['contains'] }),\n      ]),\n    ).toThrow(/handler-b/)\n\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'handler-a', operators: ['contains'] }),\n        replacementHandler({ name: 'handler-b', operators: ['contains'] }),\n      ]),\n    ).toThrow(/contains/)\n  })\n\n  it('does not throw when two build handlers target the same operator but declare disjoint fieldTypes', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'text', operators: ['contains'], fieldTypes: ['text'] }),\n        replacementHandler({ name: 'number', operators: ['contains'], fieldTypes: ['number'] }),\n      ]),\n    ).not.toThrow()\n  })\n\n  it('throws when two build handlers target the same operator and at least one declares no fieldTypes', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'unrestricted', operators: ['contains'] }),\n        replacementHandler({ name: 'text', operators: ['contains'], fieldTypes: ['text'] }),\n      ]),\n    ).toThrow()\n  })\n\n  it('throws when a handler object defines both build and transformOperands', () => {\n    const malformed = {\n      name: 'malformed',\n      operators: ['contains'],\n      build: () => null as any,\n      transformOperands: ({ column, value }: any) => ({ column, value }),\n    } as unknown as DrizzleOperatorHandler\n\n    expect(() => validateOperatorHandlers([malformed])).toThrow(/malformed/)\n  })\n})\n"],"names":["describe","expect","it","validateOperatorHandlers","transformHandler","overrides","name","operators","transformOperands","column","value","replacementHandler","build","not","toThrow","fieldTypes","malformed"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAI7C,SAASC,wBAAwB,QAAQ,gCAA+B;AAExE,MAAMC,mBAAmB,CACvBC,YAA6C,CAAC,CAAC,GAE9C,CAAA;QACCC,MAAM;QACNC,WAAW;YAAC;SAAW;QACvBC,mBAAmB,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAE,GAAM,CAAA;gBAAED;gBAAQC;YAAM,CAAA;QAC3D,GAAGL,SAAS;IACd,CAAA;AAEF,MAAMM,qBAAqB,CACzBN,YAA6C,CAAC,CAAC,GAE9C,CAAA;QACCC,MAAM;QACNC,WAAW;YAAC;SAAW;QACvBK,OAAO,IAAM;QACb,GAAGP,SAAS;IACd,CAAA;AAEFL,SAAS,4BAA4B;IACnCE,GAAG,oDAAoD;QACrDD,OAAO,IAAME,yBAAyB,EAAE,GAAGU,GAAG,CAACC,OAAO;IACxD;IAEAZ,GAAG,+EAA+E;QAChFD,OAAO,IACLE,yBAAyB;gBACvBC,iBAAiB;oBAAEE,MAAM;gBAAI;gBAC7BF,iBAAiB;oBAAEE,MAAM;gBAAI;gBAC7BF,iBAAiB;oBAAEE,MAAM;gBAAI;aAC9B,GACDO,GAAG,CAACC,OAAO;IACf;IAEAZ,GAAG,yGAAyG;QAC1GD,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;gBAChEI,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;aACjE,GACDO,OAAO,CAAC;QAEVb,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;gBAChEI,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;aACjE,GACDO,OAAO,CAAC;QAEVb,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;gBAChEI,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;aACjE,GACDO,OAAO,CAAC;IACZ;IAEAZ,GAAG,mGAAmG;QACpGD,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAQC,WAAW;wBAAC;qBAAW;oBAAEQ,YAAY;wBAAC;qBAAO;gBAAC;gBACjFJ,mBAAmB;oBAAEL,MAAM;oBAAUC,WAAW;wBAAC;qBAAW;oBAAEQ,YAAY;wBAAC;qBAAS;gBAAC;aACtF,GACDF,GAAG,CAACC,OAAO;IACf;IAEAZ,GAAG,mGAAmG;QACpGD,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAgBC,WAAW;wBAAC;qBAAW;gBAAC;gBACnEI,mBAAmB;oBAAEL,MAAM;oBAAQC,WAAW;wBAAC;qBAAW;oBAAEQ,YAAY;wBAAC;qBAAO;gBAAC;aAClF,GACDD,OAAO;IACX;IAEAZ,GAAG,yEAAyE;QAC1E,MAAMc,YAAY;YAChBV,MAAM;YACNC,WAAW;gBAAC;aAAW;YACvBK,OAAO,IAAM;YACbJ,mBAAmB,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAO,GAAM,CAAA;oBAAED;oBAAQC;gBAAM,CAAA;QAClE;QAEAT,OAAO,IAAME,yBAAyB;gBAACa;aAAU,GAAGF,OAAO,CAAC;IAC9D;AACF"}