@stamhoofd/sql 2.119.0 → 2.120.1

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

@@ -1,917 +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('$contains', () => {
-    /**
-     * Tests that should be repeated for all filter types
-     */
-    describe('Common checks', () => {
-        // todo
-    });
-    it('Throws when passing non-string values', async () => {
-        const filters = {
-            ...SQLFilter_js_1.baseSQLFilterCompilers,
-            name: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('name'), type: SQLFilter_js_1.SQLValueType.String, nullable: false }),
-        };
-        await (0, index_js_1.testMultipleErrors)({
-            testFilters: [
-                {
-                    name: {
-                        $contains: ['test'],
-                    },
-                },
-            ],
-            filters,
-            error: 'Invalid compare value. Expected a string, number, boolean, date or null.',
-        });
-        await (0, index_js_1.testMultipleErrors)({
-            testFilters: [
-                {
-                    name: {
-                        $contains: 123,
-                    },
-                },
-                {
-                    name: {
-                        $contains: true,
-                    },
-                },
-            ],
-            filters,
-            error: 'Cannot compare',
-        });
-        await (0, index_js_1.testMultipleErrors)({
-            testFilters: [
-                {
-                    name: {
-                        $contains: null,
-                    },
-                },
-            ],
-            filters,
-            error: 'Expected string at $contains filter',
-        });
-    });
-    describe('Searching in native string columns', () => {
-        it('Removes caps in the query', async () => {
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                name: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('name'), type: SQLFilter_js_1.SQLValueType.String, nullable: false }),
-            };
-            await (0, index_js_1.test)({
-                filter: {
-                    name: {
-                        $contains: 'Caps Are Removed',
-                    },
-                },
-                filters,
-                query: {
-                    query: '`default`.`name` LIKE ?',
-                    params: ['%caps are removed%'],
-                },
-            });
-        });
-        it('Escapes percentage', async () => {
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                name: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('name'), type: SQLFilter_js_1.SQLValueType.String, nullable: false }),
-            };
-            await (0, index_js_1.test)({
-                filter: {
-                    name: {
-                        $contains: '%',
-                    },
-                },
-                filters,
-                query: {
-                    query: '`default`.`name` LIKE ?',
-                    params: ['%\\%%'],
-                },
-            });
-        });
-        it('Escapes underscore', async () => {
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                name: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('name'), type: SQLFilter_js_1.SQLValueType.String, nullable: false }),
-            };
-            await (0, index_js_1.test)({
-                filter: {
-                    name: {
-                        $contains: '_',
-                    },
-                },
-                filters,
-                query: {
-                    query: '`default`.`name` LIKE ?',
-                    params: ['%\\_%'],
-                },
-            });
-        });
-        it('Escapes backslash characters', async () => {
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                name: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('name'), type: SQLFilter_js_1.SQLValueType.String, nullable: false }),
-            };
-            await (0, index_js_1.test)({
-                filter: {
-                    name: {
-                        $contains: '\\%',
-                    },
-                },
-                filters,
-                query: {
-                    query: '`default`.`name` LIKE ?',
-                    params: ['%\\\\\\%%'],
-                },
-            });
-        });
-    });
-    describe('MySQL behaviour', () => {
-        describe('Native MySQL strings', () => {
-            const tableDefinition = {
-                name: {
-                    type: 'varchar',
-                    nullable: true,
-                },
-            };
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                name: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.column('name'), type: SQLFilter_js_1.SQLValueType.String, nullable: true }),
-            };
-            it('Can actually search for %', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            name: 'This contains 50% more',
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            name: {
-                                $contains: '50%',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '0%',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '%',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            name: {
-                                $contains: '%%',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '%50',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Does not return values without % when filtering for %', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            name: 'This contains 50 percent more',
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            name: {
-                                $contains: '%',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Can actually search for _', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            name: 'john_doe@example.com',
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            name: {
-                                $contains: 'john_doe',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '_',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '_doe',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            name: {
-                                $contains: '__',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: 'john__doe',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Does not return values without _ when filtering for _', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            name: 'johndoe@example.com',
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            name: {
-                                $contains: '_',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: 'john_',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Can search for backslash', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            name: 'john\\%doe',
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            name: {
-                                $contains: '\\',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '\\%',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            name: {
-                                $contains: '\\_',
-                            },
-                        },
-                        {
-                            name: {
-                                $contains: '\\\\',
-                            },
-                        },
-                    ],
-                });
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            name: 'john\\doe',
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            name: {
-                                $contains: '\\%',
-                            },
-                        },
-                    ],
-                });
-            });
-        });
-        // Same, but for JSON strings:
-        describe('JSON strings', () => {
-            const tableDefinition = {
-                settings: {
-                    type: 'json',
-                    nullable: true,
-                },
-            };
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                '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: false }),
-            };
-            it('Can actually search for %', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                name: 'This contains 50% more',
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '50%',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '0%',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '%',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '%%',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '%50',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Does not return values without % when filtering for %', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                name: 'This contains 50 percent more',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '%',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Can actually search for _', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                name: 'john_doe@example.com',
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.name': {
-                                $contains: 'john_doe',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '_',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '_doe',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '__',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: 'john__doe',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Does not return values without _ when filtering for _', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                name: 'johndoe@example.com',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '_',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: 'john_',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Can search for backslash', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                name: 'john\\%doe',
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '\\',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '\\%',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '\\_',
-                            },
-                        },
-                        {
-                            'settings.name': {
-                                $contains: '\\\\',
-                            },
-                        },
-                    ],
-                });
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                name: 'john\\doe',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.name': {
-                                $contains: '\\%',
-                            },
-                        },
-                    ],
-                });
-            });
-        });
-        describe('JSON arrays', () => {
-            const tableDefinition = {
-                settings: {
-                    type: 'json',
-                    nullable: true,
-                },
-            };
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                settings: {
-                    ...SQLFilter_js_1.baseSQLFilterCompilers,
-                    names: (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.jsonExtract(SQL_js_1.SQL.column('settings'), '$.names'), type: SQLFilter_js_1.SQLValueType.JSONArray, nullable: false }),
-                },
-            };
-            it('Can search in the array', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                names: ['apple', 'BAnana', 'cherry'],
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.names': {
-                                $contains: 'pple',
-                            },
-                        },
-                        {
-                            settings: {
-                                names: {
-                                    $contains: 'pple',
-                                },
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: 'banana',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: 'BAnana',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.names': {
-                                $contains: 'chrry',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Can search for % in the array', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                names: ['apple', 'BAn%ana', 'cherry'],
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.names': {
-                                $contains: '%',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: 'BAn%ana',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.names': {
-                                $contains: 'BAnana',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: '%%',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Can search for backslash in the array', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                names: ['apple', 'BAn\\ana', 'cherry'],
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.names': {
-                                $contains: '\\',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: 'BAn\\ana',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.names': {
-                                $contains: 'BAnana',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: '\\\\',
-                            },
-                        },
-                    ],
-                });
-            });
-        });
-        describe('JSON wildcard arrays', () => {
-            const tableDefinition = {
-                settings: {
-                    type: 'json',
-                    nullable: true,
-                },
-            };
-            const filters = {
-                ...SQLFilter_js_1.baseSQLFilterCompilers,
-                'settings.names': (0, SQLFilter_js_1.createColumnFilter)({ expression: SQL_js_1.SQL.jsonExtract(SQL_js_1.SQL.column('settings'), '$.parents[*].name'), type: SQLFilter_js_1.SQLValueType.JSONArray, nullable: false }),
-            };
-            it('Can search in the array', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                parents: [
-                                    { name: 'apple' },
-                                    { name: 'BAnana' },
-                                    { name: 'cherry' },
-                                ],
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.names': {
-                                $contains: 'pple',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: 'banana',
-                            },
-                        },
-                        {
-                            'settings.names': {
-                                $contains: 'BAnana',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.names': {
-                                $contains: 'chrry',
-                            },
-                        },
-                    ],
-                });
-            });
-        });
-        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 actually search strings for %', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                scalar: 'This contains 50% more',
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '50%',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '0%',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '%',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '%%',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '%50',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Null fields do not match', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                scalar: null,
-                            },
-                        },
-                        {
-                            settings: {
-                                other: 15,
-                            },
-                        },
-                    ],
-                    doMatch: [],
-                    doNotMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '15',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Number fields are converted to strings', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                scalar: 15,
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '1',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '5',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '15',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '2',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '151',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Negative number fields are converted to strings', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                scalar: -15,
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '1',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '5',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '-',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '15',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '-15',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '-1',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '2',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '151',
-                            },
-                        },
-                    ],
-                });
-            });
-            it('Booleans are converted to strings', async () => {
-                await (0, index_js_1.testMatch)({
-                    tableDefinition,
-                    filters,
-                    rows: [
-                        {
-                            settings: {
-                                scalar: true,
-                            },
-                        },
-                    ],
-                    doMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: 'true',
-                            },
-                        },
-                    ],
-                    doNotMatch: [
-                        {
-                            'settings.scalar': {
-                                $contains: '1',
-                            },
-                        },
-                        {
-                            'settings.scalar': {
-                                $contains: '0',
-                            },
-                        },
-                    ],
-                });
-            });
-        });
-    });
-});
-//# sourceMappingURL=$contains.test.js.map