@payloadcms/drizzle 4.0.0-canary.35 → 4.0.0-canary.36

package/dist/find/buildPolymorphicJoinWhere.spec.js

@@ -1,805 +0,0 @@
-import { createClient } from '@libsql/client';
-import { like, notLike } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/libsql';
-import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-import { afterAll, describe, expect, it, vi } from 'vitest';
-import { operatorMap } from '../queries/operatorMap.js';
-import { createJSONQuery } from '../sqlite/createJSONQuery/index.js';
-import { buildPolymorphicJoinWhere } from './buildPolymorphicJoinWhere.js';
-const articlesTable = sqliteTable('join_articles', {
-    id: integer('id').primaryKey(),
-    parent: integer('parent_id'),
-    score: integer('score'),
-    title: text('title')
-});
-const notesTable = sqliteTable('join_notes', {
-    id: integer('id').primaryKey(),
-    parent: integer('parent_id'),
-    title: text('title')
-});
-const client = createClient({
-    url: 'file::memory:'
-});
-const db = drizzle(client, {
-    schema: {
-        articlesTable,
-        notesTable
-    }
-});
-const textField = {
-    name: 'title',
-    type: 'text'
-};
-const numberField = {
-    name: 'score',
-    type: 'number'
-};
-const hasManySelectField = {
-    hasMany: true,
-    name: 'tags',
-    options: [
-        'available',
-        'reviewed'
-    ],
-    type: 'select'
-};
-const adapter = {
-    createJSONQuery,
-    drizzle: db,
-    idType: 'serial',
-    name: 'sqlite',
-    operatorHandlers: [],
-    operators: {
-        ...operatorMap,
-        contains: like,
-        like,
-        not_like: notLike
-    },
-    payload: {
-        collections: {}
-    },
-    tableNameMap: new Map([
-        [
-            'articles_tags',
-            'join_articles_tags'
-        ],
-        [
-            'notes_tags',
-            'join_notes_tags'
-        ]
-    ]),
-    tables: {
-        join_articles: articlesTable,
-        join_notes: notesTable
-    }
-};
-const scalarPlan = ({ collections = [
-    'articles'
-], columnPath, field = textField, schemaPath = columnPath })=>new Map([
-        [
-            schemaPath,
-            {
-                columnPath,
-                fieldsByCollection: new Map(collections.map((collection)=>[
-                        collection,
-                        {
-                            field,
-                            isUUID: false,
-                            type: 'scalar'
-                        }
-                    ])),
-                schemaPath,
-                type: 'scalar'
-            }
-        ]
-    ]);
-const hasManySelectPlan = (collections = [
-    'articles'
-], schemaPath = 'tags')=>new Map([
-        [
-            schemaPath,
-            {
-                columnPath: schemaPath.replaceAll('.', '_'),
-                fieldsByCollection: new Map(collections.map((collection)=>[
-                        collection,
-                        {
-                            field: hasManySelectField,
-                            type: 'hasManySelect'
-                        }
-                    ])),
-                schemaPath,
-                type: 'hasManySelect'
-            }
-        ]
-    ]);
-const renderWhere = ({ collection = 'articles', table = articlesTable, where, wherePlan })=>{
-    const condition = buildPolymorphicJoinWhere({
-        adapter,
-        collection,
-        table,
-        where,
-        wherePlan
-    });
-    return db.select({
-        id: table.id
-    }).from(table).where(condition).toSQL();
-};
-afterAll(()=>client.close());
-describe('buildPolymorphicJoinWhere', ()=>{
-    it('builds scalar comparisons and preserves nested AND and OR groups', ()=>{
-        const wherePlan = scalarPlan({
-            columnPath: 'title',
-            collections: [
-                'articles',
-                'notes'
-            ]
-        });
-        const query = renderWhere({
-            where: {
-                AND: [
-                    {
-                        title: {
-                            equals: 'available'
-                        }
-                    },
-                    {
-                        OR: [
-                            {
-                                title: {
-                                    equals: 'reviewed'
-                                }
-                            },
-                            {
-                                title: {
-                                    equals: 'published'
-                                }
-                            }
-                        ]
-                    }
-                ]
-            },
-            wherePlan
-        });
-        expect(query.sql).toContain('where ("join_articles"."title" = ? and');
-        expect(query.sql).toContain('or');
-        expect(query.params).toEqual([
-            'available',
-            'reviewed',
-            'published'
-        ]);
-    });
-    it('treats a numeric like comparison as equality', ()=>{
-        const query = renderWhere({
-            where: {
-                score: {
-                    like: '5'
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'score',
-                field: numberField
-            })
-        });
-        expect(query.sql).toContain('"join_articles"."score" = ?');
-        expect(query.params).toEqual([
-            5
-        ]);
-    });
-    it('uses SQL NULL for a scalar field that is absent from the current collection', ()=>{
-        const query = renderWhere({
-            collection: 'notes',
-            table: notesTable,
-            where: {
-                score: {
-                    exists: false
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'score',
-                collections: [
-                    'articles'
-                ],
-                field: numberField
-            })
-        });
-        expect(query.sql).toContain('where null is null');
-        expect(query.params).toEqual([]);
-    });
-    it.each([
-        [
-            'exists',
-            {
-                exists: 'false'
-            },
-            'where null is null',
-            []
-        ],
-        [
-            'in',
-            {
-                in: '1,2'
-            },
-            'where null in (?, ?)',
-            [
-                1,
-                2
-            ]
-        ]
-    ])('normalizes a REST %s value when a scalar field is absent from the current collection', (_operator, constraint, expectedSQL, expectedParams)=>{
-        const query = renderWhere({
-            collection: 'notes',
-            table: notesTable,
-            where: {
-                score: constraint
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'score',
-                collections: [
-                    'articles'
-                ],
-                field: numberField
-            })
-        });
-        expect(query.sql).toContain(expectedSQL);
-        expect(query.params).toEqual(expectedParams);
-    });
-    it('keeps contains wildcard handling when a scalar field is absent', ()=>{
-        const query = renderWhere({
-            collection: 'notes',
-            table: notesTable,
-            where: {
-                score: {
-                    contains: '5'
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'score',
-                collections: [
-                    'articles'
-                ],
-                field: numberField
-            })
-        });
-        expect(query.sql).toContain('where null like ?');
-        expect(query.params).toEqual([
-            '%5%'
-        ]);
-    });
-    it('compares relationTo with the current collection slug', ()=>{
-        const wherePlan = new Map([
-            [
-                'relationTo',
-                {
-                    columnPath: 'relationTo',
-                    fieldsByCollection: new Map(),
-                    schemaPath: 'relationTo',
-                    type: 'scalar'
-                }
-            ]
-        ]);
-        const query = renderWhere({
-            collection: 'notes',
-            table: notesTable,
-            where: {
-                relationTo: {
-                    equals: 'notes'
-                }
-            },
-            wherePlan
-        });
-        expect(query.sql).toContain('where ? = ?');
-        expect(query.params).toEqual([
-            'notes',
-            'notes'
-        ]);
-    });
-    it.each([
-        [
-            'exists',
-            {
-                exists: 'false'
-            },
-            'where ? is null',
-            [
-                'notes'
-            ]
-        ],
-        [
-            'in',
-            {
-                in: 'articles,notes'
-            },
-            'where ? in (?, ?)',
-            [
-                'notes',
-                'articles',
-                'notes'
-            ]
-        ]
-    ])('normalizes a REST %s value for relationTo', (_operator, constraint, expectedSQL, expectedParams)=>{
-        const wherePlan = new Map([
-            [
-                'relationTo',
-                {
-                    columnPath: 'relationTo',
-                    fieldsByCollection: new Map(),
-                    schemaPath: 'relationTo',
-                    type: 'scalar'
-                }
-            ]
-        ]);
-        const query = renderWhere({
-            collection: 'notes',
-            table: notesTable,
-            where: {
-                relationTo: constraint
-            },
-            wherePlan
-        });
-        expect(query.sql).toContain(expectedSQL);
-        expect(query.params).toEqual(expectedParams);
-    });
-    it.each([
-        [
-            'equals null',
-            {
-                title: {
-                    equals: null
-                }
-            },
-            '"join_articles"."title" is null',
-            []
-        ],
-        [
-            'not_equals null',
-            {
-                title: {
-                    not_equals: null
-                }
-            },
-            '"join_articles"."title" is not null',
-            []
-        ],
-        [
-            'not_equals a value',
-            {
-                title: {
-                    not_equals: 'restricted'
-                }
-            },
-            '"join_articles"."title" is null or "join_articles"."title" <> ?',
-            [
-                'restricted'
-            ]
-        ],
-        [
-            'in values including null',
-            {
-                title: {
-                    in: [
-                        'available',
-                        null
-                    ]
-                }
-            },
-            '"join_articles"."title" is null or "join_articles"."title" in (?)',
-            [
-                'available'
-            ]
-        ]
-    ])('keeps null semantics for %s', (_description, where, expectedSQL, expectedParams)=>{
-        const query = renderWhere({
-            where: where,
-            wherePlan: scalarPlan({
-                columnPath: 'title'
-            })
-        });
-        expect(query.sql).toContain(expectedSQL);
-        expect(query.params).toEqual(expectedParams);
-    });
-    it('requires every word in a scalar like comparison', ()=>{
-        const query = renderWhere({
-            where: {
-                title: {
-                    like: 'available child'
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'title'
-            })
-        });
-        expect(query.sql).toContain('"join_articles"."title" like ? and');
-        expect(query.params).toEqual([
-            '%available%',
-            '%child%'
-        ]);
-    });
-    it('applies configured operator handlers to scalar comparisons', ()=>{
-        const transformOperands = vi.fn(({ column, value })=>({
-                column,
-                value: `handled-${String(value)}`
-            }));
-        const handler = {
-            name: 'prefix-value',
-            operators: [
-                'equals'
-            ],
-            transformOperands
-        };
-        const adapterWithHandler = {
-            ...adapter,
-            operatorHandlers: [
-                handler
-            ]
-        };
-        const condition = buildPolymorphicJoinWhere({
-            adapter: adapterWithHandler,
-            collection: 'articles',
-            table: articlesTable,
-            where: {
-                title: {
-                    equals: 'available'
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'title'
-            })
-        });
-        const query = db.select({
-            id: articlesTable.id
-        }).from(articlesTable).where(condition).toSQL();
-        expect(transformOperands).toHaveBeenCalledWith(expect.objectContaining({
-            path: 'title',
-            resolvedOperator: 'equals',
-            storage: 'column'
-        }));
-        expect(query.params).toEqual([
-            'handled-available'
-        ]);
-    });
-    it('queries a has-many select through its value table', ()=>{
-        const query = renderWhere({
-            where: {
-                tags: {
-                    contains: 'available'
-                }
-            },
-            wherePlan: hasManySelectPlan()
-        });
-        expect(query.sql).toContain('json_group_array(join_articles_tags.value)');
-        expect(query.sql).toContain("value = 'available'");
-    });
-    it.each([
-        [
-            'a REST exists value',
-            {
-                exists: 'false'
-            },
-            [
-                'NOT EXISTS (SELECT 1 FROM json_each(',
-                'AS tags_alias_0)'
-            ]
-        ],
-        [
-            'a comma-delimited REST in value',
-            {
-                in: 'available,reviewed'
-            },
-            [
-                "tags_alias_0.value = 'available'",
-                ' OR ',
-                "tags_alias_0.value = 'reviewed'"
-            ]
-        ]
-    ])('normalizes %s for has-many selects', (_description, constraint, fragments)=>{
-        const query = renderWhere({
-            where: {
-                tags: constraint
-            },
-            wherePlan: hasManySelectPlan()
-        });
-        for (const fragment of fragments){
-            expect(query.sql).toContain(fragment);
-        }
-    });
-    it.each([
-        [
-            'without a schema',
-            undefined
-        ],
-        [
-            'with a schema',
-            'content'
-        ]
-    ])('rejects a missing has-many select value table mapping %s', (_description, schemaName)=>{
-        const adapterWithoutValueTable = {
-            ...adapter,
-            schemaName,
-            tableNameMap: new Map()
-        };
-        expect(()=>buildPolymorphicJoinWhere({
-                adapter: adapterWithoutValueTable,
-                collection: 'articles',
-                table: articlesTable,
-                where: {
-                    tags: {
-                        equals: 'available'
-                    }
-                },
-                wherePlan: hasManySelectPlan()
-            })).toThrow('Polymorphic join collection "articles" has no value table for "tags"');
-    });
-    it('uses an empty JSON array when a has-many select is absent from this collection', ()=>{
-        const query = renderWhere({
-            collection: 'notes',
-            table: notesTable,
-            where: {
-                tags: {
-                    exists: false
-                }
-            },
-            wherePlan: hasManySelectPlan([
-                'articles'
-            ])
-        });
-        expect(query.sql).toContain("json_each('[]')");
-        expect(query.sql).not.toContain('join_notes_tags');
-    });
-    it('builds a false condition for an empty has-many in comparison', ()=>{
-        const query = renderWhere({
-            where: {
-                tags: {
-                    in: []
-                }
-            },
-            wherePlan: hasManySelectPlan()
-        });
-        expect(query.sql).toContain('where false');
-    });
-    it('builds a false condition for an empty scalar in comparison', ()=>{
-        const query = renderWhere({
-            where: {
-                title: {
-                    in: []
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'title'
-            })
-        });
-        expect(query.sql).toContain('where false');
-    });
-    it.each([
-        [
-            'a scalar in value that cannot be normalized',
-            {
-                title: {
-                    in: true
-                }
-            },
-            scalarPlan({
-                columnPath: 'title'
-            })
-        ],
-        [
-            'an undefined scalar in value',
-            {
-                title: {
-                    in: undefined
-                }
-            },
-            scalarPlan({
-                columnPath: 'title'
-            })
-        ],
-        [
-            'a has-many select in value that cannot be normalized',
-            {
-                tags: {
-                    in: true
-                }
-            },
-            hasManySelectPlan()
-        ]
-    ])('rejects %s', (_description, where, wherePlan)=>{
-        expect(()=>renderWhere({
-                where: where,
-                wherePlan
-            })).toThrow(Object.keys(where)[0] === 'tags' ? 'tags.in' : 'title.in');
-    });
-    it.each([
-        'AND',
-        'OR'
-    ])('rejects a value that cannot be normalized inside an %s group', (booleanOperator)=>{
-        expect(()=>renderWhere({
-                where: {
-                    [booleanOperator]: [
-                        {
-                            title: {
-                                in: true
-                            }
-                        },
-                        {
-                            title: {
-                                equals: 'available'
-                            }
-                        }
-                    ]
-                },
-                wherePlan: scalarPlan({
-                    columnPath: 'title'
-                })
-            })).toThrow('title.in');
-    });
-    it.each([
-        [
-            'equals',
-            {
-                equals: 'available'
-            },
-            [
-                "tags_alias_0.value = 'available'"
-            ]
-        ],
-        [
-            'exists',
-            {
-                exists: true
-            },
-            [
-                'EXISTS (SELECT 1 FROM json_each(',
-                'AS tags_alias_0)'
-            ]
-        ],
-        [
-            'in',
-            {
-                in: [
-                    'available',
-                    'reviewed'
-                ]
-            },
-            [
-                "tags_alias_0.value = 'available'",
-                ' OR ',
-                "tags_alias_0.value = 'reviewed'"
-            ]
-        ],
-        [
-            'like',
-            {
-                like: 'avail'
-            },
-            [
-                "tags_alias_0.value like '%avail%'"
-            ]
-        ]
-    ])('supports the %s operator for has-many selects', (_operator, constraint, expectedSQLFragments)=>{
-        const query = renderWhere({
-            where: {
-                tags: constraint
-            },
-            wherePlan: hasManySelectPlan()
-        });
-        expect(query.sql).toContain('join_articles_tags');
-        for (const expectedSQLFragment of expectedSQLFragments){
-            expect(query.sql).toContain(expectedSQLFragment);
-        }
-        expect(query.params).toEqual([]);
-    });
-    it('accepts a string $raw constraint', ()=>{
-        const query = renderWhere({
-            where: {
-                title: {
-                    $raw: 'length(title) > 3'
-                }
-            },
-            wherePlan: scalarPlan({
-                columnPath: 'title'
-            })
-        });
-        expect(query.sql).toContain('where length(title) > 3');
-    });
-    it.each([
-        [
-            'an invalid path plan',
-            {
-                title: {
-                    equals: 'available'
-                }
-            },
-            new Map([
-                [
-                    'title',
-                    {
-                        columnPath: 'title',
-                        fieldsByCollection: new Map(),
-                        schemaPath: 'title',
-                        type: 'invalid'
-                    }
-                ]
-            ]),
-            'title.equals'
-        ],
-        [
-            'a missing path plan',
-            {
-                title: {
-                    equals: 'available'
-                }
-            },
-            new Map(),
-            'title'
-        ],
-        [
-            'an unsupported has-many operator',
-            {
-                tags: {
-                    not_equals: 'available'
-                }
-            },
-            hasManySelectPlan(),
-            'tags.not_equals'
-        ],
-        [
-            'an unknown scalar operator',
-            {
-                title: {
-                    near: 'available'
-                }
-            },
-            scalarPlan({
-                columnPath: 'title'
-            }),
-            'title.near'
-        ],
-        [
-            'a non-string $raw value',
-            {
-                title: {
-                    $raw: 1
-                }
-            },
-            scalarPlan({
-                columnPath: 'title'
-            }),
-            'title.$raw'
-        ]
-    ])('rejects %s', (_description, where, wherePlan, errorPath)=>{
-        expect(()=>buildPolymorphicJoinWhere({
-                adapter,
-                collection: 'articles',
-                table: articlesTable,
-                where: where,
-                wherePlan: wherePlan
-            })).toThrow(errorPath);
-    });
-    it('returns no condition for empty boolean groups', ()=>{
-        expect(buildPolymorphicJoinWhere({
-            adapter,
-            collection: 'articles',
-            table: articlesTable,
-            where: {
-                AND: [],
-                OR: []
-            },
-            wherePlan: new Map()
-        })).toBeUndefined();
-    });
-    it.each([
-        'AND',
-        'OR'
-    ])('rejects a malformed %s group', (operator)=>{
-        expect(()=>buildPolymorphicJoinWhere({
-                adapter,
-                collection: 'articles',
-                table: articlesTable,
-                where: {
-                    [operator]: 'not-an-array'
-                },
-                wherePlan: new Map()
-            })).toThrow(operator);
-    });
-});
-
-//# sourceMappingURL=buildPolymorphicJoinWhere.spec.js.map