@stamhoofd/sql 2.108.0 → 2.109.0

package/src/SQLExpressions.ts

@@ -421,6 +421,21 @@ export class SQLColumnExpression implements SQLExpression {
     }
 }
 
+export class SQLIfNull implements SQLExpression {
+    constructor(private readonly columnExpression: SQLColumnExpression, private readonly value: string | number) {
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'IFNULL(',
+            this.columnExpression.getSQL(options),
+            ',',
+            new SQLSafeValue(this.value).getSQL(),
+            ')',
+        ]);
+    }
+}
+
 export class SQLTableExpression implements SQLNamedExpression {
     /**
      * By default the table name will be used as the namespace by MySQL.
@@ -539,3 +554,19 @@ export class SQLIf implements SQLExpression {
         ]);
     }
 }
+
+export class SQLCoalesce implements SQLExpression {
+    expressions: SQLExpression[] = [];
+
+    constructor(...expressions: SQLExpression[]) {
+        this.expressions = expressions;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'COALESCE(',
+            joinSQLQuery(this.expressions.map(e => e.getSQL(options)), ', '),
+            ')',
+        ]);
+    }
+}

package/src/SQLJoin.ts

@@ -1,4 +1,5 @@
 import { SQLExpression, SQLExpressionOptions, SQLNamedExpression, SQLQuery, joinSQLQuery } from './SQLExpression';
+import { SQLSelect } from './SQLSelect';
 import { Whereable } from './SQLWhere';
 
 export enum SQLJoinType {
@@ -29,6 +30,22 @@ export class SQLJoin extends Whereable(EmptyClass) implements SQLExpression {
     }
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
+        // add parenthesis if the table is a select
+        if (this.table instanceof SQLSelect) {
+            return joinSQLQuery([
+                this.getJoinPrefix(),
+                '(',
+                this.table?.getSQL(options),
+                `) as ${this.table.getName()}`,
+                this._where ? 'ON' : undefined,
+                this._where?.getSQL({
+                    ...options,
+                    parentNamespace: options?.defaultNamespace,
+                    defaultNamespace: this.table.getName(),
+                }),
+            ], ' ');
+        }
+
         return joinSQLQuery([
             this.getJoinPrefix(),
             this.table?.getSQL(options),

package/src/SQLJsonExpressions.ts

@@ -99,6 +99,22 @@ export class SQLJsonExtract implements SQLExpression {
     }
 }
 
+export class SQLJsonType implements SQLExpression {
+    target: SQLExpression;
+
+    constructor(target: SQLExpression) {
+        this.target = target;
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return joinSQLQuery([
+            'JSON_TYPE(',
+            this.target.getSQL(options),
+            ')',
+        ]);
+    }
+}
+
 /**
  * Same as target->path, JSON_EXTRACT(target, path)
  */

package/src/SQLSelect.ts

@@ -29,6 +29,8 @@ export type IterableSQLSelectOptions = {
     maxQueries?: number;
 };
 
+export type SQLNamedSelect<T extends object = SQLResultNamespacedRow> = SQLSelect<T> & { getName(): string };
+
 export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Whereable(Orderable(EmptyClass)) implements SQLExpression {
     _columns: SQLExpression[];
     _from: SQLNamedExpression;
@@ -38,6 +40,7 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
     _groupBy: SQLExpression[] = [];
     _joins: (InstanceType<typeof SQLJoin>)[] = [];
     _max_execution_time: number | null = null;
+    private _name: string | null = null;
 
     _transformer: ((row: SQLResultNamespacedRow) => T) | null = null;
 
@@ -74,7 +77,11 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
     }
 
     join(join: InstanceType<typeof SQLJoin>): this {
-        this._joins.push(join);
+        // prevent duplicate joins (reference of join should be the same)
+        if (!this._joins.includes(join)) {
+            this._joins.push(join);
+        }
+
         return this;
     }
 
@@ -248,7 +255,6 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
         this._orderBy = null;
 
         const { query, params } = normalizeSQLQuery(this.getSQL());
-        // console.log(query, params);
 
         const [rows] = await Database.select(query, params, { nestTables: true });
         if (rows.length === 1) {
@@ -489,4 +495,19 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
             },
         } as IterableSQLSelect<T[]> as any;
     }
+
+    getName(): string | null {
+        return this._name;
+    }
+
+    /**
+     * By calling this method we make sure a name is set so we can return an SQLNamedSelect.
+     * @param name name of the select
+     * @returns an SQLNamedSelect
+     */
+    as(name: string): SQLNamedSelect {
+        this._name = name;
+
+        return this as SQLNamedSelect;
+    }
 }

package/src/SQLTranslatedStringHelper.ts

@@ -0,0 +1,40 @@
+import { SQL, SQLColumnExpression, SQLExpression, SQLExpressionOptions, SQLQuery } from '@stamhoofd/sql';
+import { Language } from '@stamhoofd/structures';
+
+export class SQLTranslatedStringHelper implements SQLExpression {
+    constructor(private columnExpression: SQLColumnExpression, private path: string, private getLanguage: () => Language) {
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        const currentLanguage = this.getLanguage();
+
+        const languageOrder: Language[] = [
+            Language.English,
+            Language.Dutch,
+            Language.French,
+        ];
+
+        const languages = moveToFront(languageOrder, currentLanguage);
+
+        const languageValues: SQLExpression[] = languages.map((language) => {
+            return SQL.jsonValue(this.columnExpression, `${this.path}.${language}`, 'CHAR');
+        });
+
+        const type: SQLExpression = SQL.jsonType(SQL.jsonExtract(this.columnExpression, this.path));
+
+        return SQL.if(
+            type, '=', 'STRING',
+        ).then(
+            SQL.jsonValue(this.columnExpression, this.path, 'CHAR'),
+        ).else(
+            SQL.coalesce(...languageValues) as SQLExpression,
+        ).getSQL(options);
+    }
+}
+
+function moveToFront<T>(arr: T[], value: T): T[] {
+    const index = arr.indexOf(value);
+    if (index === -1 || index === 0) return arr;
+
+    return [arr[index], ...arr.slice(0, index), ...arr.slice(index + 1)];
+}

package/src/filters/SQLSorter.ts

@@ -2,10 +2,10 @@ import { PlainObject } from '@simonbackx/simple-encoding';
 import { SortDefinition, SortList } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
-import { SQLExpression } from '../SQLExpression';
-import { SQLJoin } from '../SQLJoin';
-import { SQLOrderBy, SQLOrderByDirection } from '../SQLOrderBy';
-import { SQLSelect } from '../SQLSelect';
+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;