@stamhoofd/sql 2.83.5 → 2.84.0

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

@@ -0,0 +1,701 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SQLModernFilter_1 = require("../../src/filters/modern/SQLModernFilter");
+const SQL_1 = require("../../src/SQL");
+const utils_1 = require("../utils");
+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 = {
+            ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+            name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+        };
+        await (0, utils_1.testMultipleErrors)({
+            testFilters: [
+                {
+                    name: {
+                        $contains: ['test'],
+                    },
+                },
+            ],
+            filters,
+            error: 'Invalid compare value',
+        });
+        await (0, utils_1.testMultipleErrors)({
+            testFilters: [
+                {
+                    name: {
+                        $contains: 123,
+                    },
+                },
+                {
+                    name: {
+                        $contains: true,
+                    },
+                },
+            ],
+            filters,
+            error: 'Cannot compare',
+        });
+        await (0, utils_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 = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+            };
+            await (0, utils_1.test)({
+                filter: {
+                    name: {
+                        $contains: 'Caps Are Removed',
+                    },
+                },
+                filters,
+                query: {
+                    query: '`default`.`name` LIKE ?',
+                    params: ['%caps are removed%'],
+                },
+            });
+        });
+        it('Escapes percentage', async () => {
+            const filters = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+            };
+            await (0, utils_1.test)({
+                filter: {
+                    name: {
+                        $contains: '%',
+                    },
+                },
+                filters,
+                query: {
+                    query: '`default`.`name` LIKE ?',
+                    params: ['%\\%%'],
+                },
+            });
+        });
+        it('Escapes underscore', async () => {
+            const filters = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+            };
+            await (0, utils_1.test)({
+                filter: {
+                    name: {
+                        $contains: '_',
+                    },
+                },
+                filters,
+                query: {
+                    query: '`default`.`name` LIKE ?',
+                    params: ['%\\_%'],
+                },
+            });
+        });
+        it('Escapes backslash characters', async () => {
+            const filters = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: false }),
+            };
+            await (0, utils_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 = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                name: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.column('name'), type: SQLModernFilter_1.SQLModernValueType.String, nullable: true }),
+            };
+            it('Can actually search for %', async () => {
+                await (0, utils_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, utils_1.testMatch)({
+                    tableDefinition,
+                    filters,
+                    rows: [
+                        {
+                            name: 'This contains 50 percent more',
+                        },
+                    ],
+                    doNotMatch: [
+                        {
+                            name: {
+                                $contains: '%',
+                            },
+                        },
+                    ],
+                });
+            });
+            it('Can actually search for _', async () => {
+                await (0, utils_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, utils_1.testMatch)({
+                    tableDefinition,
+                    filters,
+                    rows: [
+                        {
+                            name: 'johndoe@example.com',
+                        },
+                    ],
+                    doNotMatch: [
+                        {
+                            name: {
+                                $contains: '_',
+                            },
+                        },
+                        {
+                            name: {
+                                $contains: 'john_',
+                            },
+                        },
+                    ],
+                });
+            });
+            it('Can search for backslash', async () => {
+                await (0, utils_1.testMatch)({
+                    tableDefinition,
+                    filters,
+                    rows: [
+                        {
+                            name: 'john\\%doe',
+                        },
+                    ],
+                    doMatch: [
+                        {
+                            name: {
+                                $contains: '\\',
+                            },
+                        },
+                        {
+                            name: {
+                                $contains: '\\%',
+                            },
+                        },
+                    ],
+                    doNotMatch: [
+                        {
+                            name: {
+                                $contains: '\\_',
+                            },
+                        },
+                        {
+                            name: {
+                                $contains: '\\\\',
+                            },
+                        },
+                    ],
+                });
+                await (0, utils_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 = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                'settings.name': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.name'), type: SQLModernFilter_1.SQLModernValueType.JSONString, nullable: false }),
+            };
+            it('Can actually search for %', async () => {
+                await (0, utils_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, utils_1.testMatch)({
+                    tableDefinition,
+                    filters,
+                    rows: [
+                        {
+                            settings: {
+                                name: 'This contains 50 percent more',
+                            },
+                        },
+                    ],
+                    doNotMatch: [
+                        {
+                            'settings.name': {
+                                $contains: '%',
+                            },
+                        },
+                    ],
+                });
+            });
+            it('Can actually search for _', async () => {
+                await (0, utils_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, utils_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, utils_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, utils_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 = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                settings: {
+                    ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                    names: (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.names'), type: SQLModernFilter_1.SQLModernValueType.JSONArray, nullable: false }),
+                },
+            };
+            it('Can search in the array', async () => {
+                await (0, utils_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, utils_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, utils_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 = {
+                ...SQLModernFilter_1.baseModernSQLFilterCompilers,
+                'settings.names': (0, SQLModernFilter_1.createColumnFilter)({ expression: SQL_1.SQL.jsonValue(SQL_1.SQL.column('settings'), '$.parents[*].name'), type: SQLModernFilter_1.SQLModernValueType.JSONArray, nullable: false }),
+            };
+            it('Can search in the array', async () => {
+                await (0, utils_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',
+                            },
+                        },
+                    ],
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=$contains.test.js.map