@stamhoofd/sql 2.115.1 → 2.117.0

package/src/QueryableModel.ts

@@ -1,20 +1,33 @@
 import { Model, SQLResultNamespacedRow } from '@simonbackx/simple-database';
-import { SQLSelect } from './SQLSelect';
-import { SQL } from './SQL';
-import { SQLDelete } from './SQLDelete';
-import { SQLUpdate } from './SQLUpdate';
-import { SQLInsert } from './SQLInsert';
-import { SQLExpression } from './SQLExpression';
+import { SQLSelect } from './SQLSelect.js';
+import { SQL } from './SQL.js';
+import { SQLDelete } from './SQLDelete.js';
+import { SQLUpdate } from './SQLUpdate.js';
+import { SQLInsert } from './SQLInsert.js';
+import { SQLExpression } from './SQLExpression.js';
+import { ModelCache } from './ModelCache.js';
 
 export class QueryableModel extends Model {
-    static select<T extends typeof Model>(this: T, ...columns: (SQLExpression | string)[]): SQLSelect<InstanceType<T>> {
+    rawSelectedRow: SQLResultNamespacedRow | null = null;
+    static cache: ModelCache<QueryableModel> | null = null;
+
+    static select<T extends typeof Model & typeof QueryableModel>(this: T, ...columns: (SQLExpression | string)[]): SQLSelect<InstanceType<T>> {
         const transformer = (row: SQLResultNamespacedRow): InstanceType<T> => {
-            const d = (this as T).fromRow(row[this.table] as any) as InstanceType<T> | undefined;
+            const d = (this as T).fromRow(row[this.table]) as InstanceType<T> | undefined;
+
+            if (this.cache && d) {
+                this.cache.store(d);
+            }
+
+            // If there are any other namespaces, include it as metadata
 
             if (!d) {
                 console.error('Could not transform row', row, 'into model', this.table, 'check if the primary key is returned in the query');
                 throw new Error('Missing data for model ' + this.table);
             }
+            if (d instanceof QueryableModel) {
+                d.rawSelectedRow = row;
+            }
 
             return d;
         };
@@ -68,4 +81,54 @@ export class QueryableModel extends Model {
             }
         }
     }
+
+    /**
+     * Get a model by its primary key
+     * @param id primary key
+     */
+    static override async getByID<T extends typeof Model>(this: T & typeof QueryableModel, id: number | string, required: true): Promise<InstanceType<T>>;
+    static override async getByID<T extends typeof Model>(this: T & typeof QueryableModel, id: number | string): Promise<InstanceType<T> | undefined>;
+    static override async getByID<T extends typeof Model>(this: T & typeof QueryableModel, id: number | string, required?: boolean): Promise<InstanceType<T> | undefined> {
+        if (this.cache) {
+            const hit = this.cache.getById(id);
+            if (hit) {
+                console.log('Cache hit, get by id', this.name, id);
+                return hit as InstanceType<T>;
+            }
+        }
+        return ((await (this as any as typeof QueryableModel).select().where(this.primary.name, id).first(required ?? false)) ?? undefined) as any as InstanceType<T> | undefined;
+    }
+
+    /**
+     * Get multiple models by their ID
+     * @param ids primary key of the models you want to fetch
+     */
+    static override async getByIDs<T extends typeof Model>(this: T & typeof QueryableModel, ...ids: (number | string)[]): Promise<InstanceType<T>[]> {
+        if (ids.length === 0) {
+            return [];
+        }
+
+        if (this.cache) {
+            const hits: InstanceType<T>[] = [];
+            const remaining: (number | string)[] = [];
+            for (const id of ids) {
+                const hit = this.cache.getById(id);
+                if (hit) {
+                    console.log('Cache hit, get by id', this.name, id);
+                    hits.push(hit as InstanceType<T>);
+                }
+                else {
+                    remaining.push(id);
+                }
+            }
+            ids = remaining;
+            if (remaining.length === 0) {
+                return hits;
+            }
+            const fetched = await (this as any as typeof QueryableModel).select().where(this.primary.name, ids).limit(ids.length).fetch() as any as InstanceType<T>[];
+            return [...fetched, ...hits];
+        }
+
+        return (this as any as typeof QueryableModel).select().where(this.primary.name, ids).limit(ids.length).fetch() as any as InstanceType<T>[];
+    }
 }

package/src/SQLExpressions.ts

@@ -37,7 +37,7 @@ export class SQLDistinct implements SQLExpression {
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
         return joinSQLQuery([
-            'DISTINCT',
+            'DISTINCT ',
             this.expression.getSQL(options),
         ]);
     }

package/src/SQLJoin.ts

@@ -1,6 +1,6 @@
-import { SQLExpression, SQLExpressionOptions, SQLNamedExpression, SQLQuery, joinSQLQuery } from './SQLExpression';
-import { SQLSelect } from './SQLSelect';
-import { Whereable } from './SQLWhere';
+import { SQLExpression, SQLExpressionOptions, SQLNamedExpression, SQLQuery, joinSQLQuery } from './SQLExpression.js';
+import { SQLSelect } from './SQLSelect.js';
+import { Whereable } from './SQLWhere.js';
 
 export enum SQLJoinType {
     Left = 'Left',

package/src/SQLJsonExpressions.ts

@@ -1,6 +1,6 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression';
-import { SQLJSONFalse, SQLJSONNull, SQLJSONTrue, SQLSafeValue, SQLScalar, SQLScalarValue } from './SQLExpressions';
-import { SQLWhere } from './SQLWhere';
+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) {

package/src/SQLLogger.ts

@@ -4,6 +4,7 @@ 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
@@ -18,14 +19,19 @@ class StaticSQLLogger {
         return null;
     }
 
-    async logInefficientExplainResult(query: string, params: any[], explainResult: any) {
+    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:',
+                `Inefficient query detected${elapsedTimeMs !== undefined ? ' (' + elapsedTimeMs.toFixed(0) + 'ms)' : ''}:`,
                 query,
                 params,
                 'EXPLAIN result:',
@@ -55,8 +61,17 @@ class StaticSQLLogger {
             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));
+            await this.logInefficientExplainResult(query, params, await this.explain(query, params), elapsedTimeMs);
             return result;
         }
 

package/src/SQLOrderBy.ts

@@ -1,9 +1,9 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression';
-import { SQLColumnExpression } from './SQLExpressions';
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery } from './SQLExpression.js';
+import { SQLColumnExpression } from './SQLExpressions.js';
 
-type Constructor<T = {}> = new (...args: any[]) => T;
+type Constructor<T = object> = new (...args: any[]) => T;
 
-export function Orderable<Sup extends Constructor<{}>>(Base: Sup) {
+export function Orderable<Sup extends Constructor<object>>(Base: Sup) {
     return class extends Base {
         _orderBy: SQLOrderBy | null = null;
 

package/src/SQLSelect.ts

@@ -98,6 +98,10 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
     }
 
     getSQL(options?: SQLExpressionOptions): SQLQuery {
+        if (!this._from) {
+            throw new Error('Forgot to define .from(...) for SQLSelect');
+        }
+
         const query: SQLQuery[] = [
             'SELECT',
         ];
@@ -229,6 +233,7 @@ export class SQLSelect<T extends object = SQLResultNamespacedRow> extends Wherea
 
     first(required: false): Promise<T | null>;
     first(required: true): Promise<T>;
+    first(required: boolean): Promise<T | null>;
     async first(required = true): Promise<T | null> {
         const rows = await this.limit(1).fetch();
         if (rows.length === 0) {

package/src/SQLWhere.ts

@@ -1,9 +1,9 @@
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from './SQLExpression';
-import { SQLArray, SQLColumnExpression, SQLDynamicExpression, SQLNull, readDynamicSQLExpression } from './SQLExpressions';
-import { SQLJoin, SQLJoinType } from './SQLJoin';
-import { SQLSelect } from './SQLSelect';
+import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from './SQLExpression.js';
+import { SQLArray, SQLColumnExpression, SQLDynamicExpression, SQLNull, readDynamicSQLExpression } from './SQLExpressions.js';
+import { SQLJoin, SQLJoinType } from './SQLJoin.js';
+import { SQLSelect } from './SQLSelect.js';
 
-type Constructor<T = {}> = new (...args: any[]) => T;
+type Constructor<T = object> = new (...args: any[]) => T;
 
 export enum SQLWhereSign {
     Equal = '=',

package/src/filters/SQLFilter.ts

@@ -1,12 +1,13 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { compileFilter, FilterCompiler, FilterDefinitions, filterDefinitionsToCompiler, RequiredFilterCompiler, StamhoofdFilter } from '@stamhoofd/structures';
-import { SQLExpression, SQLExpressionOptions, SQLQuery } from '../SQLExpression';
-import { SQLJoin } from '../SQLJoin';
-import { SQLJsonValue } from '../SQLJsonExpressions';
-import { SQLSelect } from '../SQLSelect';
-import { SQLWhere, SQLWhereAnd, SQLWhereExists, SQLWhereJoin, SQLWhereNot, SQLWhereOr } from '../SQLWhere';
-import { $equalsSQLFilterCompiler, $greaterThanSQLFilterCompiler, $inSQLFilterCompiler, $lessThanSQLFilterCompiler } from './compilers';
-import { $containsSQLFilterCompiler } from './compilers/contains';
+import { SQLExpression, SQLExpressionOptions, SQLQuery } from '../SQLExpression.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';
 
 export type SQLSyncFilterRunner = (column: SQLCurrentColumn) => SQLWhere;
 export type SQLFilterRunner = (column: SQLCurrentColumn) => Promise<SQLWhere> | SQLWhere;
@@ -123,7 +124,9 @@ export function createExistsFilter(baseSelect: InstanceType<typeof SQLSelect> &
                 type: SQLValueType.Table,
                 nullable: false,
             });
-            const q = baseSelect.clone().andWhere(w);
+            const q = baseSelect.clone();
+            q._columns = [new SQLSafeValue(1)];
+            q.andWhere(w);
             return new SQLWhereExists(q);
         };
     };

package/src/filters/compilers/contains.ts

@@ -1,10 +1,10 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression, SQLLower, SQLNull } from '../../SQLExpressions';
-import { SQLJsonSearch } from '../../SQLJsonExpressions';
-import { SQLWhereEqual, SQLWhereLike, SQLWhereSign } from '../../SQLWhere';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner, SQLValueType } from '../SQLFilter';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue';
+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) => {

package/src/filters/compilers/equals.ts

@@ -1,10 +1,10 @@
 import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression, SQLLower, SQLNull } from '../../SQLExpressions';
-import { SQLJsonContains, SQLJsonSearch, SQLJsonValue } from '../../SQLJsonExpressions';
-import { SQLWhere, SQLWhereEqual, SQLWhereLike, SQLWhereOr, SQLWhereSign } from '../../SQLWhere';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner, SQLValueType } from '../SQLFilter';
-import { isJSONColumn } from '../helpers/isJSONColumn';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue';
+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) => {

package/src/filters/compilers/greater.ts

@@ -1,8 +1,8 @@
 import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression } from '../../SQLExpressions';
-import { SQLWhereEqual, SQLWhereSign } from '../../SQLWhere';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner } from '../SQLFilter';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue';
+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) => {

package/src/filters/compilers/in.ts

@@ -1,11 +1,11 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression, SQLArray } from '../../SQLExpressions';
-import { SQLJsonOverlaps } from '../../SQLJsonExpressions';
-import { SQLWhereEqual, SQLWhereOr, SQLWhereSign } from '../../SQLWhere';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner, SQLValueType } from '../SQLFilter';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue';
-import { $equalsSQLFilterCompiler } from './equals';
+import { scalarToSQLExpression, SQLArray } from '../../SQLExpressions.js';
+import { SQLJsonOverlaps } from '../../SQLJsonExpressions.js';
+import { SQLWhereEqual, SQLWhereOr, SQLWhereSign } from '../../SQLWhere.js';
+import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner, SQLValueType } from '../SQLFilter.js';
+import { normalizeCompareValue } from '../helpers/normalizeCompareValue.js';
+import { $equalsSQLFilterCompiler } from './equals.js';
 
 export function $inSQLFilterCompiler(filter: StamhoofdFilter): SQLSyncFilterRunner {
     return (originalColumn: SQLCurrentColumn) => {

package/src/filters/compilers/index.ts

@@ -1,4 +1,4 @@
-export * from './less';
-export * from './greater';
-export * from './equals';
-export * from './in';
+export * from './less.js';
+export * from './greater.js';
+export * from './equals.js';
+export * from './in.js';

package/src/filters/compilers/less.ts

@@ -1,8 +1,8 @@
 import { assertFilterCompareValue, StamhoofdFilter } from '@stamhoofd/structures';
-import { scalarToSQLExpression } from '../../SQLExpressions';
-import { SQLWhereEqual, SQLWhereSign } from '../../SQLWhere';
-import { normalizeColumn, SQLCurrentColumn, SQLSyncFilterRunner } from '../SQLFilter';
-import { normalizeCompareValue } from '../helpers/normalizeCompareValue';
+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) => {

package/src/filters/helpers/isJSONColumn.ts

@@ -1,4 +1,4 @@
-import { SQLCurrentColumn, SQLValueType } from '../SQLFilter';
+import { SQLCurrentColumn, SQLValueType } from '../SQLFilter.js';
 
 export function isJSONColumn({ type }: SQLCurrentColumn): boolean {
     return isJSONType(type);

package/src/filters/helpers/normalizeCompareValue.ts

@@ -1,5 +1,5 @@
 import { StamhoofdCompareValue } from '@stamhoofd/structures';
-import { SQLValueType } from '../SQLFilter';
+import { SQLValueType } from '../SQLFilter.js';
 
 /**
  * Prepares a compare value so we can compare it, given a certain column type.