@stamhoofd/sql 2.118.1 → 2.119.0

package/src/filters/SQLFilter.ts

@@ -1,13 +1,13 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { compileFilter, FilterCompiler, FilterDefinitions, filterDefinitionsToCompiler, RequiredFilterCompiler, StamhoofdFilter } from '@stamhoofd/structures';
+import { compileFilter, FilterCompiler, FilterDefinitions, filterDefinitionsToCompiler, RequiredFilterCompiler, type StamhoofdCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
 import { SQLExpression, SQLExpressionOptions, SQLQuery } from '../SQLExpression.js';
+import { SQLSafeValue } from '../SQLExpressions.js';
 import { SQLJoin } from '../SQLJoin.js';
 import { SQLJsonValue } from '../SQLJsonExpressions.js';
 import { SQLSelect } from '../SQLSelect.js';
 import { SQLWhere, SQLWhereAnd, SQLWhereExists, SQLWhereJoin, SQLWhereNot, SQLWhereOr } from '../SQLWhere.js';
-import { $equalsSQLFilterCompiler, $greaterThanSQLFilterCompiler, $inSQLFilterCompiler, $lessThanSQLFilterCompiler } from './compilers/index.js';
 import { $containsSQLFilterCompiler } from './compilers/contains.js';
-import { SQLSafeValue } from '../SQLExpressions.js';
+import { $equalsSQLFilterCompiler, $greaterThanSQLFilterCompiler, $inSQLFilterCompiler, $lessThanSQLFilterCompiler } from './compilers/index.js';
 
 export type SQLSyncFilterRunner = (column: SQLCurrentColumn) => SQLWhere;
 export type SQLFilterRunner = (column: SQLCurrentColumn) => Promise<SQLWhere> | SQLWhere;
@@ -34,9 +34,13 @@ export enum SQLValueType {
     /** True or false in JSON */
     JSONBoolean = 'JSONBoolean',
     JSONString = 'JSONString',
-
     JSONNumber = 'JSONNumber',
 
+    /**
+     * Either boolean, string, number or null (if nullable). Only use this if you cannot determine the type at compile time.
+     */
+    JSONScalar = 'JSONScalar',
+
     /** [...] */
     JSONArray = 'JSONArray',
 
@@ -244,8 +248,8 @@ export async function compileToSQLFilter(filter: StamhoofdFilter, filters: SQLFi
 /**
  * Casts json strings, numbers and booleans to native MySQL types. This includes json null to mysql null.
  */
-export function normalizeColumn(column: SQLCurrentColumn): SQLCurrentColumn {
-    if (column.type === SQLValueType.JSONString) {
+export function normalizeColumn(column: SQLCurrentColumn, hint?: StamhoofdCompareValue): SQLCurrentColumn {
+    if (column.type === SQLValueType.JSONString || (column.type === SQLValueType.JSONScalar && typeof hint === 'string')) {
         return {
             expression: new SQLJsonValue(column.expression, 'CHAR'),
             type: SQLValueType.String,
@@ -253,20 +257,21 @@ export function normalizeColumn(column: SQLCurrentColumn): SQLCurrentColumn {
         };
     }
 
-    if (column.type === SQLValueType.JSONBoolean) {
+    if (column.type === SQLValueType.JSONNumber || (column.type === SQLValueType.JSONScalar && typeof hint === 'number')) {
         return {
-            expression: new SQLJsonValue(column.expression, 'UNSIGNED'),
-            type: SQLValueType.Boolean,
+            expression: new SQLJsonValue(column.expression, 'SIGNED'),
+            type: SQLValueType.Number,
             nullable: column.nullable,
         };
     }
 
-    if (column.type === SQLValueType.JSONNumber) {
+    if (column.type === SQLValueType.JSONBoolean || (column.type === SQLValueType.JSONScalar && typeof hint === 'boolean')) {
         return {
             expression: new SQLJsonValue(column.expression, 'UNSIGNED'),
-            type: SQLValueType.Number,
+            type: SQLValueType.Boolean,
             nullable: column.nullable,
         };
     }
+
     return column;
 }

package/src/filters/SQLSorter.ts

@@ -44,7 +44,7 @@ export function applySQLSorter(selectQuery: SQLSelect<any>, sortBy: SortList, de
                         throw new SimpleError({
                             code: 'sorter_join_overlap',
                             message: 'This combination of sorters is not possible',
-                            human: $t('e328a7c2-318c-4425-b61a-61e6f4211707'),
+                            human: $t('%GU'),
                         });
                     }
                 }

package/src/filters/compilers/contains.ts

@@ -8,8 +8,9 @@ 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);
+        const v = assertFilterCompareValue(filter);
+        const column = normalizeColumn(originalColumn, v);
+        const value = normalizeCompareValue(v, column.type);
 
         if (typeof value !== 'string') {
             throw new SimpleError({

package/src/filters/compilers/equals.ts

@@ -8,8 +8,9 @@ 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);
+        const v = assertFilterCompareValue(filter);
+        const column = normalizeColumn(originalColumn, v);
+        const value = normalizeCompareValue(v, column.type);
         /**
          * Special case, checking for equality with a JSON array.
          * This should return true if the JSON array contains the value exactly.

package/src/filters/compilers/greater.ts

@@ -6,8 +6,9 @@ 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 v = assertFilterCompareValue(filter);
+        const column = normalizeColumn(originalColumn, v);
+        const value = normalizeCompareValue(v, column.type);
 
         const base = new SQLWhereEqual(
             column.expression,

package/src/filters/compilers/in.ts

@@ -20,18 +20,17 @@ export function $inSQLFilterCompiler(filter: StamhoofdFilter): SQLSyncFilterRunn
             throw new SimpleError({
                 code: 'invalid_filter',
                 message: 'Too many values in $in filter, maximum is 1000',
-                human: $t('2f4b0c22-044e-486b-8a75-80a5b51beaf3', { count: filter.length }),
+                human: $t('%1HH', { count: filter.length }),
             });
         }
-
-        const column = normalizeColumn(originalColumn);
-        const values = filter.map(val => normalizeCompareValue(assertFilterCompareValue(val), column.type));
-
-        if (values.length === 0) {
+        if (filter.length === 0) {
             // Return always false
             return new SQLWhereOr([]);
         }
 
+        const column = normalizeColumn(originalColumn, assertFilterCompareValue(filter.find(f => f !== null) ?? null));
+        const values = filter.map(val => normalizeCompareValue(assertFilterCompareValue(val), column.type));
+
         const valuesWithoutNulls = values.filter(val => val !== null);
         const hasNull = values.length !== valuesWithoutNulls.length;
 

package/src/filters/compilers/less.ts

@@ -6,8 +6,9 @@ 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 v = assertFilterCompareValue(filter);
+        const column = normalizeColumn(originalColumn, v);
+        const value = normalizeCompareValue(v, column.type);
 
         const base = new SQLWhereEqual(
             column.expression,

package/src/filters/helpers/isJSONColumn.ts

@@ -8,6 +8,7 @@ export function isJSONType(type: SQLValueType): boolean {
     return type === SQLValueType.JSONString
         || type === SQLValueType.JSONBoolean
         || type === SQLValueType.JSONNumber
+        || type === SQLValueType.JSONScalar
         || type === SQLValueType.JSONArray
         || type === SQLValueType.JSONObject;
 }

package/src/filters/helpers/normalizeCompareValue.ts

@@ -1,5 +1,6 @@
 import { StamhoofdCompareValue } from '@stamhoofd/structures';
 import { SQLValueType } from '../SQLFilter.js';
+import { isJSONType } from './isJSONColumn.js';
 
 /**
  * Prepares a compare value so we can compare it, given a certain column type.
@@ -26,7 +27,7 @@ export function normalizeCompareValue(val: StamhoofdCompareValue, againstType: S
     }
 
     if (typeof val === 'string') {
-        if (againstType === SQLValueType.String || againstType === SQLValueType.JSONString) {
+        if (againstType === SQLValueType.String) {
             return val.toLocaleLowerCase();
         }