@stamhoofd/sql 2.118.1 → 2.120.0

package/src/filters/SQLSorter.ts

@@ -1,60 +0,0 @@
-import { PlainObject } from '@simonbackx/simple-encoding';
-import { SortDefinition, SortList } from '@stamhoofd/structures';
-
-import { SimpleError } from '@simonbackx/simple-errors';
-import { SQLExpression } from '../SQLExpression.js';
-import { SQLJoin } from '../SQLJoin.js';
-import { SQLOrderBy, SQLOrderByDirection } from '../SQLOrderBy.js';
-import { SQLSelect } from '../SQLSelect.js';
-
-export type SQLSortDefinition<T, B extends PlainObject | Date = PlainObject | Date> = SortDefinition<T, B> & {
-    toSQL(direction: SQLOrderByDirection): SQLOrderBy;
-    join?: SQLJoin;
-    select?: (SQLExpression | string)[];
-};
-
-export type SQLSortDefinitions<T = any> = Record<string, SQLSortDefinition<T>>;
-
-export function applySQLSorter(selectQuery: SQLSelect<any>, sortBy: SortList, definitions: SQLSortDefinitions) {
-    if (sortBy.length === 0) {
-        throw new SimpleError({
-            code: 'empty_sort',
-            message: 'No sort passed',
-        });
-    }
-
-    for (const s of sortBy) {
-        const d = definitions[s.key];
-        if (!d) {
-            throw new Error('Unknown sort key ' + s.key);
-        }
-
-        selectQuery.orderBy(d.toSQL(s.order));
-
-        if (d.join) {
-            // Check if no overlap in alias/table (otherwise we'll get issues)
-            if (selectQuery._joins.find(j => j === d.join)) {
-                // Already added
-            }
-            else {
-                const name = d.join.table.getSQL({ defaultNamespace: 'default' });
-
-                for (const j of selectQuery._joins) {
-                    if (j.table.getSQL({ defaultNamespace: 'default' }) === name) {
-                        throw new SimpleError({
-                            code: 'sorter_join_overlap',
-                            message: 'This combination of sorters is not possible',
-                            human: $t('e328a7c2-318c-4425-b61a-61e6f4211707'),
-                        });
-                    }
-                }
-
-                selectQuery.join(d.join);
-            }
-        }
-
-        if (d.select) {
-            selectQuery.select(...d.select);
-        }
-    }
-}

package/src/filters/compilers/contains.ts

@@ -1,43 +0,0 @@
-import { SimpleError } from '@simonbackx/simple-errors';
-import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression, SQLLower, SQLNull } from '../../SQLExpressions.js';
-import { SQLJsonSearch } from '../../SQLJsonExpressions.js';
-import { SQLWhereEqual, SQLWhereLike, SQLWhereSign } from '../../SQLWhere.js';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner, SQLValueType } from '../SQLFilter.js';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue.js';
-
-export function $containsSQLFilterCompiler(filter: StamhoofdFilter): SQLSyncFilterRunner {
-    return (originalColumn: SQLCurrentColumn) => {
-        const column = normalizeColumn(originalColumn);
-        const value = normalizeCompareValue(assertFilterCompareValue(filter), column.type);
-
-        if (typeof value !== 'string') {
-            throw new SimpleError({
-                code: 'invalid_filter',
-                message: 'Expected string at $contains filter',
-            });
-        }
-
-        if (column.type === SQLValueType.JSONArray || column.type === SQLValueType.JSONObject) {
-            // For JSON arrays and objects, we use JSON_CONTAINS
-            return new SQLWhereEqual(
-                new SQLJsonSearch(
-                    new SQLLower(column.expression),
-                    'one',
-                    scalarToSQLExpression(
-                        '%' + SQLWhereLike.escape(value) + '%',
-                    ),
-                ),
-                SQLWhereSign.NotEqual,
-                new SQLNull(),
-            );
-        }
-
-        return new SQLWhereLike(
-            column.expression,
-            scalarToSQLExpression(
-                '%' + SQLWhereLike.escape(value) + '%',
-            ),
-        );
-    };
-}

package/src/filters/compilers/equals.ts

@@ -1,72 +0,0 @@
-import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression, SQLLower, SQLNull } from '../../SQLExpressions.js';
-import { SQLJsonContains, SQLJsonSearch, SQLJsonValue } from '../../SQLJsonExpressions.js';
-import { SQLWhere, SQLWhereEqual, SQLWhereLike, SQLWhereOr, SQLWhereSign } from '../../SQLWhere.js';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner, SQLValueType } from '../SQLFilter.js';
-import { isJSONColumn } from '../helpers/isJSONColumn.js';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue.js';
-
-export function $equalsSQLFilterCompiler(filter: StamhoofdFilter): SQLSyncFilterRunner {
-    return (originalColumn: SQLCurrentColumn) => {
-        const column = normalizeColumn(originalColumn);
-        const value = normalizeCompareValue(assertFilterCompareValue(filter), column.type);
-        /**
-         * Special case, checking for equality with a JSON array.
-         * This should return true if the JSON array contains the value exactly.
-         *
-         * This differs from $contains, which will check for 'LIKE' inside the JSON array.
-         */
-        if (column.type === SQLValueType.JSONArray) {
-            let where: SQLWhere;
-
-            if (typeof value === 'string') {
-                where = new SQLWhereEqual(
-                    new SQLJsonSearch(
-                        new SQLLower(column.expression),
-                        'one',
-                        scalarToSQLExpression(
-                            SQLWhereLike.escape(value),
-                        ),
-                    ),
-                    SQLWhereSign.NotEqual,
-                    new SQLNull(),
-                );
-            }
-            else {
-                where = new SQLJsonContains(
-                    column.expression,
-                    scalarToSQLExpression(JSON.stringify(value)),
-                );
-            }
-
-            // If comparing against null, also check for native MySQL null (the column does not exist)
-            if (value === null) {
-                where = new SQLWhereOr([
-                    where,
-                    new SQLWhereEqual(
-                        column.expression,
-                        SQLWhereSign.Equal,
-                        new SQLNull(),
-                    ),
-                ]);
-            }
-
-            return where;
-        }
-
-        if (value === null && isJSONColumn(column)) {
-            // JSON values can either resolve to null or "null" in MySQL.
-            return new SQLWhereEqual(
-                new SQLJsonValue(column.expression), // casts json null to null, including invalid paths
-                SQLWhereSign.Equal,
-                new SQLNull(),
-            );
-        }
-
-        return new SQLWhereEqual(
-            column.expression,
-            SQLWhereSign.Equal,
-            scalarToSQLExpression(value),
-        ).setNullable(column.nullable);
-    };
-}

package/src/filters/compilers/greater.ts

@@ -1,20 +0,0 @@
-import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression } from '../../SQLExpressions.js';
-import { SQLWhereEqual, SQLWhereSign } from '../../SQLWhere.js';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner } from '../SQLFilter.js';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue.js';
-
-export function $greaterThanSQLFilterCompiler(filter: StamhoofdFilter): SQLSyncFilterRunner {
-    return (originalColumn: SQLCurrentColumn) => {
-        const column = normalizeColumn(originalColumn);
-        const value = normalizeCompareValue(assertFilterCompareValue(filter), column.type);
-
-        const base = new SQLWhereEqual(
-            column.expression,
-            SQLWhereSign.Greater,
-            scalarToSQLExpression(value),
-        ).setNullable(column.nullable);
-
-        return base;
-    };
-}

package/src/filters/compilers/less.ts

@@ -1,19 +0,0 @@
-import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression } from '../../SQLExpressions.js';
-import { SQLWhereEqual, SQLWhereSign } from '../../SQLWhere.js';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner } from '../SQLFilter.js';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue.js';
-
-export function $lessThanSQLFilterCompiler(filter: StamhoofdFilter): SQLSyncFilterRunner {
-    return (originalColumn: SQLCurrentColumn) => {
-        const column = normalizeColumn(originalColumn);
-        const value = normalizeCompareValue(assertFilterCompareValue(filter), column.type);
-
-        const base = new SQLWhereEqual(
-            column.expression,
-            SQLWhereSign.Less,
-            scalarToSQLExpression(value),
-        ).setNullable(column.nullable);
-        return base;
-    };
-}