@stamhoofd/sql 2.118.1 → 2.120.0

package/src/SQLJsonExpressions.ts

@@ -1,283 +0,0 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression.js';
-import { SQLJSONFalse, SQLJSONNull, SQLJSONTrue, SQLSafeValue, SQLScalar, SQLScalarValue } from './SQLExpressions.js';
-import { SQLWhere } from './SQLWhere.js';
-
-export function scalarToSQLJSONExpression(s: SQLScalarValue | null): SQLExpression {
-    if (s === null) {
-        return SQLJSONNull;
-    }
-
-    if (s === true) {
-        return SQLJSONTrue;
-    }
-
-    if (s === false) {
-        return SQLJSONFalse;
-    }
-
-    return new SQLScalar(s);
-}
-
-export class SQLJsonUnquote implements SQLExpression {
-    target: SQLExpression;
-
-    constructor(target: SQLExpression) {
-        this.target = target;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_UNQUOTE(',
-            this.target.getSQL(options),
-            ')',
-        ]);
-    }
-}
-
-export type SQLJsonValueType = 'FLOAT' | 'DOUBLE' | 'DECIMAL' | 'SIGNED' | 'UNSIGNED' | 'DATE' | 'TIME' | 'DATETIME' | 'YEAR' | 'CHAR' | 'JSON';
-
-export class SQLJsonValue implements SQLExpression {
-    target: SQLExpression;
-    path: SQLExpression;
-    type?: SQLJsonValueType;
-
-    constructor(target: SQLExpression, type?: SQLJsonValueType, path?: SQLExpression) {
-        this.target = target;
-        this.type = type;
-
-        if (!path && target instanceof SQLJsonExtract) {
-            // If the target is a SQLJsonExtract, we can use its path directly
-            this.target = target.target;
-            this.path = target.path;
-            return;
-        }
-
-        this.path = path ?? new SQLSafeValue('$');
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_VALUE(',
-            this.target.getSQL(options),
-            ',',
-            this.path.getSQL(options),
-            (this.type ? ' RETURNING ' + this.type + (this.type === 'CHAR' ? ' CHARACTER SET utf8mb4' : '') : ''),
-            ' ERROR ON ERROR)',
-        ]);
-    }
-}
-
-/**
- * Same as target->path, JSON_EXTRACT(target, path)
- */
-export class SQLJsonExtract implements SQLExpression {
-    target: SQLExpression;
-    path: SQLExpression;
-
-    constructor(target: SQLExpression, path: SQLExpression) {
-        this.target = target;
-        this.path = path;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_EXTRACT(',
-            this.target.getSQL(options),
-            ',',
-            this.path.getSQL(options),
-            ')',
-        ]);
-    }
-
-    /**
-     * NOTE: this has to be combined with asScalar = true! Never let user input in a query without passing it as a parameter.
-     *
-     * E.g. SQL.jsonValue(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}`, true) (note that last true!)
-     */
-    static escapePathComponent(str: string) {
-        return '"' + str.replace(/(["\\])/g, '\\$1') + '"';
-    }
-}
-
-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)
- */
-export class SQLJsonKeys implements SQLExpression {
-    target: SQLExpression;
-
-    constructor(target: SQLExpression) {
-        this.target = target;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_KEYS(',
-            this.target.getSQL(options),
-            ')',
-        ]);
-    }
-}
-
-export class SQLJsonLength implements SQLExpression {
-    target: SQLExpression;
-    path?: SQLExpression;
-
-    constructor(target: SQLExpression, path?: SQLExpression) {
-        this.target = target;
-        this.path = path;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_LENGTH(',
-            this.target.getSQL(options),
-            ...(this.path
-                ? [
-                        ',',
-                        this.path.getSQL(options),
-                    ]
-                : []),
-            ')',
-        ]);
-    }
-}
-/**
- * JSON_SEARCH(json_doc, one_or_all, search_str[, escape_char[, path] ...])
- */
-export class SQLJsonSearch implements SQLExpression {
-    target: SQLExpression;
-    oneOrAll: 'one' | 'all';
-    searchStr: SQLExpression;
-    path: SQLExpression | null;
-
-    constructor(target: SQLExpression, oneOrAll: 'one' | 'all', searchStr: SQLExpression, path: SQLExpression | null = null) {
-        this.target = target;
-        this.oneOrAll = oneOrAll;
-        this.searchStr = searchStr;
-        this.path = path;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_SEARCH(',
-            this.target.getSQL(options),
-            ',',
-            new SQLSafeValue(this.oneOrAll).getSQL(options),
-            ',',
-            this.searchStr.getSQL(options),
-            ...(this.path
-                ? [
-                        ',',
-                        this.path.getSQL(options),
-                    ]
-                : []),
-            ')',
-        ]);
-    }
-}
-
-/**
- * JSON_CONTAINS(target, candidate[, path])
- */
-export class SQLJsonContains extends SQLWhere {
-    target: SQLExpression;
-    candidate: SQLExpression;
-    path: SQLExpression | null;
-
-    constructor(target: SQLExpression, candidate: SQLExpression, path: SQLExpression | null = null) {
-        super();
-        this.target = target;
-        this.candidate = candidate;
-        this.path = path;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_CONTAINS(',
-            this.target.getSQL(options),
-            ',',
-            this.candidate.getSQL(options),
-            ...(this.path
-                ? [
-                        ',',
-                        this.path.getSQL(options),
-                    ]
-                : []),
-            ')',
-        ]);
-    }
-
-    clone(): this {
-        const c = (new (this.constructor as any)(this.target, this.candidate, this.path)) as this;
-        return c;
-    }
-}
-
-/**
- * JSON_CONTAINS(json_doc1, json_doc2)
- */
-export class SQLJsonOverlaps extends SQLWhere {
-    jsonDoc1: SQLExpression;
-    jsonDoc2: SQLExpression;
-
-    constructor(jsonDoc1: SQLExpression, jsonDoc2: SQLExpression) {
-        super();
-        this.jsonDoc1 = jsonDoc1;
-        this.jsonDoc2 = jsonDoc2;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'JSON_OVERLAPS(',
-            this.jsonDoc1.getSQL(options),
-            ',',
-            this.jsonDoc2.getSQL(options),
-            ')',
-        ]);
-    }
-
-    clone(): this {
-        const c = (new (this.constructor as any)(this.jsonDoc1, this.jsonDoc2)) as this;
-        return c;
-    }
-}
-
-export class SQLLpad implements SQLExpression {
-    target: SQLExpression;
-    length: SQLExpression;
-    value: SQLExpression;
-
-    constructor(target: SQLExpression, length: SQLExpression, value: SQLExpression) {
-        this.target = target;
-        this.length = length;
-        this.value = value;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        return joinSQLQuery([
-            'LPAD(',
-            this.target.getSQL(options),
-            ',',
-            this.length.getSQL(options),
-            ',',
-            this.value.getSQL(options),
-            ')',
-        ]);
-    }
-}

package/src/SQLLogger.ts

@@ -1,82 +0,0 @@
-import { Database } from '@simonbackx/simple-database';
-import { StyledText } from '@simonbackx/simple-logging';
-
-class StaticSQLLogger {
-    slowQueryThresholdMs: number | null = null;
-    explainAllAndLogInefficient = false;
-    customLoggers: ((query: string, params: any[], elapsedTimeMs: number) => void)[] = [];
-
-    async explain(query: string, params: any[]) {
-        // Run an EXPLAIN on the query to see what is going on
-        try {
-            const explainQuery = 'EXPLAIN ' + query;
-            const [explainRows] = await Database.select(explainQuery, params, { nestTables: true });
-            return explainRows[0]?.[''] ?? null;
-        }
-        catch (e) {
-            console.error('Error running EXPLAIN on slow query', e);
-        }
-        return null;
-    }
-
-    async logInefficientExplainResult(query: string, params: any[], explainResult: any, elapsedTimeMs?: number) {
-        if (!explainResult) {
-            return;
-        }
-        if (elapsedTimeMs !== undefined && elapsedTimeMs < 20) {
-            // Probably fine
-            return;
-        }
-
-        if (explainResult['type'] === 'ALL') {
-            console.warn(
-                new StyledText('[FULL TABLE SCAN] ').addClass('error').addTag('query'),
-                `Inefficient query detected${elapsedTimeMs !== undefined ? ' (' + elapsedTimeMs.toFixed(0) + 'ms)' : ''}:`,
-                query,
-                params,
-                'EXPLAIN result:',
-                explainResult,
-            );
-        }
-    }
-
-    async log<T>(queryPromise: Promise<T>, query: string, params: any[]): Promise<T> {
-        if (this.slowQueryThresholdMs === null) {
-            if (this.explainAllAndLogInefficient) {
-                const result = await queryPromise;
-                await this.logInefficientExplainResult(query, params, await this.explain(query, params));
-                return result;
-            }
-            return queryPromise;
-        }
-
-        const startTime = process.hrtime.bigint();
-        const result = await queryPromise;
-        const elapsedTime = process.hrtime.bigint() - startTime;
-
-        // Convert to ms
-        const elapsedTimeMs = Number(elapsedTime) / 1000 / 1000;
-
-        if (elapsedTimeMs > this.slowQueryThresholdMs) {
-            console.trace('Slow SQL query (' + elapsedTimeMs.toFixed(2) + 'ms)\nQuery: ' + query, params);
-        }
-
-        for (const logger of this.customLoggers) {
-            try {
-                logger(query, params, elapsedTimeMs);
-            }
-            catch (e) {
-                console.error('Error in custom SQL logger', e);
-            }
-        }
-
-        if (this.explainAllAndLogInefficient) {
-            await this.logInefficientExplainResult(query, params, await this.explain(query, params), elapsedTimeMs);
-            return result;
-        }
-
-        return result;
-    }
-}
-
-export const SQLLogger = new StaticSQLLogger();

package/src/SQLOrderBy.ts

@@ -1,69 +0,0 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression.js';
-import { SQLColumnExpression } from './SQLExpressions.js';
-
-type Constructor<T = object> = new (...args: any[]) => T;
-
-export function Orderable<Sup extends Constructor<object>>(Base: Sup) {
-    return class extends Base {
-        _orderBy: SQLOrderBy | null = null;
-
-        orderBy<T>(this: T, orderBy: SQLOrderBy): T;
-        orderBy<T>(this: T, column: SQLExpression | string, direction?: SQLOrderByDirection): T;
-        orderBy<T>(this: T, columnOrOrderBy: SQLExpression | string, direction?: SQLOrderByDirection): T {
-            let o = columnOrOrderBy as SQLOrderBy;
-            if (!(columnOrOrderBy instanceof SQLOrderBy)) {
-                o = new SQLOrderBy({
-                    column: typeof columnOrOrderBy === 'string' ? new SQLColumnExpression(columnOrOrderBy) : columnOrOrderBy,
-                    direction: direction ?? 'ASC',
-                });
-            }
-
-            const me = this as any; // stupid typescript looses type information if we don't do the this: T dance
-
-            if (me._orderBy) {
-                me._orderBy.add(o);
-            }
-            else {
-                me._orderBy = o;
-            }
-
-            return me;
-        }
-    };
-}
-
-export type SQLOrderByDirection = 'ASC' | 'DESC';
-export class SQLOrderBy implements SQLExpression {
-    orderBy: { column: SQLExpression; direction: SQLOrderByDirection }[] = [];
-
-    constructor(...orderBy: { column: SQLExpression; direction: SQLOrderByDirection }[]) {
-        this.orderBy = orderBy;
-    }
-
-    static combine(orderBy: SQLOrderBy[]) {
-        return new SQLOrderBy(...orderBy.flatMap(o => o.orderBy));
-    }
-
-    add(orderBy: SQLOrderBy) {
-        this.orderBy.push(...orderBy.orderBy);
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        if (this.orderBy.length === 0) {
-            return '';
-        }
-
-        return joinSQLQuery([
-            'ORDER BY ',
-            joinSQLQuery(
-                this.orderBy.map((o) => {
-                    return joinSQLQuery([
-                        o.column.getSQL(options),
-                        o.direction,
-                    ], ' ');
-                }),
-                ', ',
-            ),
-        ]);
-    }
-}