@stamhoofd/sql 2.119.0 → 2.120.1

package/dist/tests/filters/$in.test.js

@@ -1,773 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLFilter_js_1 = require("../../src/filters/SQLFilter.js");
-const SQL_js_1 = require("../../src/SQL.js");
-const index_js_1 = require("../utils/index.js");
-describe('$in', () => {
-    /**
-     * Tests that should be repeated for all filter types
-     */
-    describe('Common checks', () => {
-        // todo
-    });
-    it('throws when not passing an array', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.testError)({
-            filter: {
-                age: {
-                    $in: 18,
-                },
-            },
-            filters,
-            error: 'Expected array at $in filter',
-        });
-    });
-    it('throws when passing more than 1000 values to the filter', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.testError)({
-            filter: {
-                age: {
-                    $in: Array.from({ length: 1001 }, (_, i) => i + 1),
-                },
-            },
-            filters,
-            error: 'Too many values in $in filter, maximum is 1000',
-        });
-    });
-    it('can filter on $in', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                age: {
-                    $in: [18, 19, 20],
-                },
-            },
-            filters,
-            query: {
-                query: '`default`.`age` IN (?)',
-                params: [
-                    [18, 19, 20],
-                ],
-            },
-        });
-    });
-    it('can filter on single $in', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                age: {
-                    $in: [18],
-                },
-            },
-            filters,
-            query: {
-                query: '`default`.`age` = ?',
-                params: [18],
-            },
-        });
-    });
-    it('can filter on empty $in', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                age: {
-                    $in: [],
-                },
-            },
-            filters,
-            query: {
-                query: '',
-                params: [],
-            },
-        });
-    });
-    it('can invert $in inside', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                age: {
-                    $not: {
-                        $in: [18, 19, 20],
-                    },
-                },
-            },
-            filters,
-            query: {
-                query: '`default`.`age` NOT IN (?)',
-                params: [
-                    [18, 19, 20],
-                ],
-            },
-        });
-    });
-    it('can invert $in outside', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                $not: {
-                    age: {
-                        $in: [18, 19, 20],
-                    },
-                },
-            },
-            filters,
-            query: {
-                query: '`default`.`age` NOT IN (?)',
-                params: [
-                    [18, 19, 20],
-                ],
-            },
-        });
-    });
-    it('splits up when using null', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                age: {
-                    $in: [18, 19, 20, null],
-                },
-            },
-            filters,
-            query: {
-                query: '`default`.`age` IS NULL OR `default`.`age` IN (?)',
-                params: [
-                    [18, 19, 20],
-                ],
-            },
-        });
-    });
-    it('works when only including null', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            age: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('age'), type: SQLFilter_js_1.SQLValueType.Number, nullable: false }),
-        };
-        await (0, index_js_1.test)({
-            filter: {
-                age: {
-                    $in: [null],
-                },
-            },
-            filters,
-            query: {
-                query: '`default`.`age` IS NULL',
-                params: [],
-            },
-        });
-    });
-    it('throws an error when trying to search in json objects', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            settings: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('settings'), type: SQLFilter_js_1.SQLValueType.JSONObject, nullable: false }),
-        };
-        await (0, index_js_1.testError)({
-            filter: {
-                settings: {
-                    $in: ['apple', 'banana'],
-                },
-            },
-            filters,
-            error: 'Cannot compare with a JSON object',
-        });
-    });
-    describe('JSON', () => {
-        const tableDefinition = {
-            settings: {
-                type: 'json',
-                nullable: true,
-            },
-        };
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            'settings.randomValues': (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.jsonExtract(SQL_js_1.SQL.column('settings'), '$.randomValues'), type: SQLFilter_js_1.SQLValueType.JSONArray, nullable: true }),
-            'settings.name': (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.jsonExtract(SQL_js_1.SQL.column('settings'), '$.name'), type: SQLFilter_js_1.SQLValueType.JSONString, nullable: true }),
-        };
-        it('Can check if a string is in a JSON string array, case insensitive', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            randomValues: [
-                                'apple',
-                                'Banana',
-                                'cherrY',
-                            ],
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', 'banana', 'cherry', 'other'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', 'banana', 'other'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['Apple', 'banana', 'other'],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['orange', 'kiwi'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['pple'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['àpple'],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Can check if a JSON string equals values, case insensitive', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            name: 'aPple',
-                        },
-                    },
-                    {
-                        settings: {
-                            name: 'apple',
-                        },
-                    },
-                    {
-                        settings: {
-                            name: 'APPLE',
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.name': {
-                            $in: ['apple', 'banana', 'other'],
-                        },
-                    },
-                    {
-                        'settings.name': {
-                            $in: ['apple'],
-                        },
-                    },
-                    {
-                        'settings.name': {
-                            $in: ['Apple', 'other'],
-                        },
-                    },
-                ],
-                doNotMatch: [],
-            });
-        });
-        it('Can check if an emoji is in a JSON string array', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            randomValues: [
-                                '🍎',
-                                '🍌',
-                                '👩🏽‍🎤',
-                            ],
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['🍎', '🍌', '👩🏽‍🎤', 'other'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['🍎', '🍌', 'other'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['👩🏽‍🎤', 'other'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['👩🏽‍🎤'],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['other'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['👩🏽'],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: ['👩🏻‍🎤'],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Can check if null is in a JSON array', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            randomValues: [
-                                null,
-                                'Banana',
-                                false,
-                                0,
-                            ],
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', null],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple'],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Including null will also check on key existence for json arrays', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: null,
-                    },
-                    {
-                        settings: {},
-                    },
-                    {
-                        settings: {
-                            randomValues: null,
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', null],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [null],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple'],
-                        },
-                    },
-                ],
-            });
-        });
-        it('If a json array exists and does not contain null, it is not included when checking for null', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            randomValues: [
-                                'Banana',
-                                false,
-                                0,
-                            ],
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: [false],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', null],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Including null also matches when a JSON path does not exist', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {},
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', 'banana', 'cherry', null],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: ['apple', 'banana', 'cherry'],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Can search numbers in a JSON array', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            randomValues: [
-                                null,
-                                'Banana',
-                                false,
-                                0,
-                                5,
-                                15,
-                            ],
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: [5, 15],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [5],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [15],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [99, 15],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: [6, 10],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [99, 14],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Can search booleans in a JSON array', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            randomValues: [
-                                null,
-                                'Banana',
-                                false,
-                                1,
-                            ],
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: [false, true],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [false],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.randomValues': {
-                            $in: [true],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [0],
-                        },
-                    },
-                    {
-                        'settings.randomValues': {
-                            $in: [],
-                        },
-                    },
-                ],
-            });
-        });
-    });
-    describe('JSON scalars', () => {
-        const tableDefinition = {
-            settings: {
-                type: 'json',
-                nullable: true,
-            },
-        };
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            'settings.scalar': (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.jsonExtract(SQL_js_1.SQL.column('settings'), '$.scalar'), type: SQLFilter_js_1.SQLValueType.JSONScalar, nullable: true }),
-        };
-        it('Can compare with number scalars', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            scalar: 5,
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: [5, 6, 7],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: [4, 6, 7],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Can compare case insensitive with string scalars', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            scalar: 'Hello world',
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: ['hello world'],
-                        },
-                    },
-                    {
-                        'settings.scalar': {
-                            $in: ['Hello world'],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: ['hello', 'world'],
-                        },
-                    },
-                    {
-                        'settings.scalar': {
-                            $in: [null],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Can compare with null', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            scalar: null,
-                        },
-                    },
-                    {
-                        settings: {
-                            other: 5,
-                        },
-                    },
-                    {
-                        settings: null,
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: [5, 6, 7, null],
-                        },
-                    },
-                    {
-                        'settings.scalar': {
-                            // regression: when first
-                            $in: [null, 5, 6, 7],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: [5, 6, 7],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Converts column to first provided value type (number)', async () => {
-            await (0, index_js_1.testMatch)({
-                tableDefinition,
-                filters,
-                rows: [
-                    {
-                        settings: {
-                            scalar: '5',
-                        },
-                    },
-                    {
-                        settings: {
-                            scalar: '6',
-                        },
-                    },
-                    {
-                        settings: {
-                            scalar: '07',
-                        },
-                    },
-                ],
-                doMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: [5, 6, 7],
-                        },
-                    },
-                ],
-                doNotMatch: [
-                    {
-                        'settings.scalar': {
-                            $in: [-5, -6, -7],
-                        },
-                    },
-                ],
-            });
-        });
-        it('Throws when mixing types', async () => {
-            await (0, index_js_1.testError)({
-                filter: {
-                    'settings.scalar': {
-                        $in: [18, 'hello'],
-                    },
-                },
-                filters,
-                error: 'Cannot compare a string with a non-string column',
-            });
-            await (0, index_js_1.testError)({
-                filter: {
-                    'settings.scalar': {
-                        $in: [18, '17'],
-                    },
-                },
-                filters,
-                error: 'Cannot compare a string with a non-string column',
-            });
-            await (0, index_js_1.testError)({
-                filter: {
-                    'settings.scalar': {
-                        $in: ['hello', 18],
-                    },
-                },
-                filters,
-                error: 'Cannot compare a number with a non-number column',
-            });
-        });
-    });
-});
-//# sourceMappingURL=$in.test.js.map