@stamhoofd/sql 2.10.2 → 2.16.0

package/src/SQLWhere.ts

@@ -1,22 +1,27 @@
 import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from "./SQLExpression";
-import { SQLArray, SQLDynamicExpression, SQLNull, readDynamicSQLExpression } from "./SQLExpressions";
+import { SQLArray, SQLColumnExpression, SQLDynamicExpression, SQLNull, readDynamicSQLExpression } from "./SQLExpressions";
 
-type GConstructor<T = {}> = new (...args: any[]) => T;
-type Whereable = GConstructor<{ _where: SQLWhere|null }>;
+type Constructor<T = {}> = new (...args: any[]) => T;
 
 export type ParseWhereArguments = [
     where: SQLWhere
 ] | [
-    whereOrColumn: SQLExpression, 
+    whereOrColumn: SQLExpression|string, 
     sign: SQLWhereSign, 
     value: SQLDynamicExpression
 ] | [
-    whereOrColumn: SQLExpression, 
+    whereOrColumn: SQLExpression|string, 
     value: SQLDynamicExpression
 ]
 
-export function addWhereHelpers<TBase extends Whereable>(Base: TBase) {
+function assertWhereable(o: any): any {
+    return o;
+}
+
+export function Whereable<Sup extends Constructor<{}>>(Base: Sup) {
     return class extends Base {
+        _where: SQLWhere|null = null
+
         parseWhere(...[whereOrColumn, signOrValue, value]: ParseWhereArguments): SQLWhere {
             if (signOrValue === undefined) {
                 return whereOrColumn as SQLWhere;
@@ -24,63 +29,71 @@ export function addWhereHelpers<TBase extends Whereable>(Base: TBase) {
 
             if (value !== undefined) {
                 return new SQLWhereEqual(
-                    whereOrColumn, 
+                    typeof whereOrColumn === 'string' ? new SQLColumnExpression(whereOrColumn) : whereOrColumn, 
                     signOrValue as SQLWhereSign, 
                     readDynamicSQLExpression(value)
                 )
             }
             return new SQLWhereEqual(
-                whereOrColumn, 
+                typeof whereOrColumn === 'string' ? new SQLColumnExpression(whereOrColumn) : whereOrColumn, 
                 SQLWhereSign.Equal,
                 readDynamicSQLExpression(signOrValue)
             )
         }
 
+
         where<T>(this: T, ...args: ParseWhereArguments): T {
-            const w = (this as any).parseWhere(...args);
-            if (!(this as any)._where) {
-                (this as any)._where = w;
-                return this;
+            const me = assertWhereable(this)
+
+            const w = me.parseWhere(...args);
+            if (!me._where) {
+                me._where = w;
+                return me;
             }
-            (this as any)._where = (this as any)._where.and(w);
-            return this;
+            me._where = me._where.and(w);
+            return me;
         }
 
-        andWhere(...args: ParseWhereArguments) {
-            return this.where(...args)
+        andWhere<T>(this: T, ...args: ParseWhereArguments): T {
+            const me = assertWhereable(this)
+            return me.where(...args)
         }
 
-        orWhere(...args: ParseWhereArguments) {
-            const w = this.parseWhere(...args);
-            if (!this._where) {
-                this._where = w;
+        orWhere<T>(this: T, ...args: ParseWhereArguments): T {
+            const me = assertWhereable(this)
+            const w = me.parseWhere(...args);
+            if (!me._where) {
+                me._where = w;
                 return this;
             }
-            this._where = this._where.or(w);
+            me._where = me._where.or(w);
             return this;
         }
 
-        whereNot(...args: ParseWhereArguments) {
-            const w = new SQLWhereNot(this.parseWhere(...args));
-            if (!this._where) {
-                this._where = w;
+        whereNot<T>(this: T, ...args: ParseWhereArguments): T {
+            const me = assertWhereable(this)
+            const w = new SQLWhereNot(me.parseWhere(...args));
+            if (!me._where) {
+                me._where = w;
                 return this;
             }
-            this._where = this._where.and(w);
+            me._where = me._where.and(w);
             return this;
         }
 
-        andWhereNot(...args: ParseWhereArguments) {
-            return this.whereNot(...args)
+        andWhereNot<T>(this: T, ...args: ParseWhereArguments): T {
+            const me = assertWhereable(this)
+            return me.whereNot(...args)
         }
 
-        orWhereNot(...args: ParseWhereArguments) {
-             const w = new SQLWhereNot(this.parseWhere(...args));
-            if (!this._where) {
-                this._where = w;
+        orWhereNot<T>(this: T, ...args: ParseWhereArguments): T {
+            const me = assertWhereable(this)
+            const w = new SQLWhereNot(me.parseWhere(...args));
+            if (!me._where) {
+                me._where = w;
                 return this;
             }
-            this._where = this._where.or(w);
+            me._where = me._where.or(w);
             return this;
         }
     }

package/src/filters/SQLFilter.ts

@@ -1,8 +1,8 @@
 import { SimpleError } from "@simonbackx/simple-errors";
-import { StamhoofdFilter, StamhoofdKeyFilterValue } from "@stamhoofd/structures";
+import { StamhoofdFilter } from "@stamhoofd/structures";
 import { SQL } from "../SQL";
 import { SQLExpression } from "../SQLExpression";
-import { SQLArray, SQLColumnExpression, SQLNull, SQLSafeValue, SQLScalarValue, scalarToSQLExpression, scalarToSQLJSONExpression } from "../SQLExpressions";
+import { SQLArray, SQLCast, SQLColumnExpression, SQLNull, SQLSafeValue, SQLScalarValue, scalarToSQLExpression, scalarToSQLJSONExpression } from "../SQLExpressions";
 import { SQLJsonContains, SQLJsonOverlaps, SQLJsonSearch, SQLJsonUnquote } from "../SQLJsonExpressions";
 import { SQLSelect } from "../SQLSelect";
 import { SQLWhere, SQLWhereAnd, SQLWhereEqual, SQLWhereExists, SQLWhereLike, SQLWhereNot, SQLWhereOr, SQLWhereSign } from "../SQLWhere";
@@ -65,7 +65,9 @@ export function createSQLFilterNamespace(definitions: SQLFilterDefinitions): SQL
     }
 }
 
-export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression, normalizeValue?: (v: SQLScalarValue|null) => SQLScalarValue|null, isJSONValue = false, isJSONObject = false): SQLFilterCompiler {
+type SQLExpressionFilterOptions = {normalizeValue?: (v: SQLScalarValue|null) => SQLScalarValue|null, isJSONValue?: boolean, isJSONObject?: boolean, nullable?: boolean}
+
+export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression, {normalizeValue, isJSONObject = false, isJSONValue = false, nullable = false}: SQLExpressionFilterOptions = {}): SQLFilterCompiler {
     const norm = normalizeValue ?? ((v) => v);
     const convertToExpression = isJSONValue ? scalarToSQLJSONExpression : scalarToSQLExpression
 
@@ -172,15 +174,6 @@ export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression,
             if (isJSONObject) {
                 const v = norm(f.$eq);
 
-                // if (typeof v === 'string') {
-                //     return new SQLWhereEqual(
-                //         new SQLJsonSearch(sqlExpression, 'one', convertToExpression(v)), 
-                //         SQLWhereSign.Equal, 
-                //         new SQLNull()
-                //     );
-                // }
-
-                // else
                 return new SQLWhereEqual(
                     new SQLJsonContains(
                         sqlExpression, 
@@ -204,6 +197,8 @@ export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression,
                 // > null is same as not equal to null (everything is larger than null in mysql) - to be consistent with order by behaviour
                 return new SQLWhereEqual(sqlExpression, SQLWhereSign.NotEqual, convertToExpression(null));
             }
+
+            // For MySQL null values are never included in greater than, but we need this for consistent sorting behaviour
             return new SQLWhereEqual(sqlExpression, SQLWhereSign.Greater, convertToExpression(norm(f.$gt)));
         }
 
@@ -232,6 +227,17 @@ export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression,
                 // <= null is same as equal to null
                 return new SQLWhereEqual(sqlExpression, SQLWhereSign.Equal, convertToExpression(norm(f.$lte)));
             }
+
+            const base = new SQLWhereEqual(sqlExpression, SQLWhereSign.LessEqual, convertToExpression(norm(f.$lte)));
+
+            if (nullable) {
+                return new SQLWhereOr([
+                    // Null values are also smaller than any value  - required for sorting
+                    new SQLWhereEqual(sqlExpression, SQLWhereSign.Equal, new SQLNull()),
+                   base
+                ]);
+            }
+            
             return new SQLWhereEqual(sqlExpression, SQLWhereSign.LessEqual, convertToExpression(norm(f.$lte)));
         }
 
@@ -247,7 +253,18 @@ export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression,
                 // < null is always nothing, there is nothing smaller than null in MySQL - to be consistent with order by behaviour
                 return new SQLWhereEqual(new SQLSafeValue(1), SQLWhereSign.Equal, new SQLSafeValue(0));
             }
-            return new SQLWhereEqual(sqlExpression, SQLWhereSign.Less, convertToExpression(norm(f.$lt)));
+
+            const base = new SQLWhereEqual(sqlExpression, SQLWhereSign.Less, convertToExpression(norm(f.$lt)))
+
+            if (nullable) {
+                return new SQLWhereOr([
+                    // Null values are also smaller than any value  - required for sorting
+                    new SQLWhereEqual(sqlExpression, SQLWhereSign.Equal, new SQLNull()),
+                   base
+                ]);
+            }
+
+            return base;
         }
 
         if ('$contains' in f) {
@@ -266,6 +283,16 @@ export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression,
                     new SQLNull()
                 );
             }
+
+            if (isJSONValue) {
+                // We need to do case insensitive search, so need to convert the sqlExpression from utf8mb4 to varchar
+                return new SQLWhereLike(
+                    new SQLCast(new SQLJsonUnquote(sqlExpression), 'CHAR'), 
+                    convertToExpression(
+                        '%'+SQLWhereLike.escape(f.$contains)+'%'
+                    )
+                );
+            }
             
             return new SQLWhereLike(
                 sqlExpression, 
@@ -279,9 +306,9 @@ export function createSQLExpressionFilterCompiler(sqlExpression: SQLExpression,
     }
 }
 
-export function createSQLColumnFilterCompiler(name: string | SQLColumnExpression, normalizeValue?: (v: SQLScalarValue|null) => SQLScalarValue|null): SQLFilterCompiler {
+export function createSQLColumnFilterCompiler(name: string | SQLColumnExpression, options?: SQLExpressionFilterOptions): SQLFilterCompiler {
     const column = name instanceof SQLColumnExpression ? name : SQL.column(name);
-    return createSQLExpressionFilterCompiler(column, normalizeValue)
+    return createSQLExpressionFilterCompiler(column, options)
 }
 
 export const baseSQLFilterCompilers: SQLFilterDefinitions = {