@stamhoofd/sql 2.119.0 → 2.120.1

package/src/QueryableModel.ts

@@ -1,134 +0,0 @@
-import { Model, SQLResultNamespacedRow } from '@simonbackx/simple-database';
-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 {
-    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 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;
-        };
-
-        const select = new SQLSelect(transformer, ...(columns.length === 0 ? [SQL.wildcard()] : columns));
-        return select.from(SQL.table(this.table));
-    }
-
-    static delete(): SQLDelete {
-        return SQL.delete().from(SQL.table(this.table));
-    }
-
-    static update(): SQLUpdate {
-        return SQL.update(SQL.table(this.table));
-    }
-
-    static insert(): SQLInsert {
-        return SQL.insert(SQL.table(this.table));
-    }
-
-    async refresh() {
-        const { fields, skipUpdate } = this.getChangedDatabaseProperties();
-
-        if (Object.keys(fields).length > skipUpdate) {
-            throw new Error('Cannot refresh a model that has unsaved changes');
-        }
-
-        const me = await (this.static as typeof QueryableModel).select().where(this.static.primary.name, this.getPrimaryKey()).first(true);
-        this.copyFrom(me);
-    }
-
-    static async refreshAll<T extends typeof QueryableModel>(this: T, list: InstanceType<T>[]) {
-        // Cut up in batches of max 100
-        const batchSize = 100;
-        for (let i = 0; i < list.length; i += batchSize) {
-            const batch = list.slice(i, i + batchSize);
-            const ids = list.map(item => item.getPrimaryKey()).filter(id => id !== null);
-            if (ids.length === 0) {
-                continue;
-            }
-
-            const refreshed = await this.getByIDs(...ids);
-
-            for (const item of batch) {
-                const refreshedItem = refreshed.find(r => r.getPrimaryKey() === item.getPrimaryKey());
-                if (refreshedItem) {
-                    for (const column of this.columns.values()) {
-                        item[column.name] = refreshedItem[column.name];
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 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/SQL.ts

@@ -1,128 +0,0 @@
-import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
-import { SQLDelete } from './SQLDelete.js';
-import { isSQLExpression, SQLExpression } from './SQLExpression.js';
-import { SQLAssignment, SQLCoalesce, SQLColumnExpression, SQLColumnExpressionParams, SQLDistinct, SQLIf, SQLIsNull, SQLJSONTableExpression, SQLParentNamespace, SQLSafeValue, SQLScalar, SQLScalarValue, SQLTableExpression, SQLWildcardSelectExpression } from './SQLExpressions.js';
-import { SQLInsert } from './SQLInsert.js';
-import { SQLJoin, SQLJoinType } from './SQLJoin.js';
-import { SQLJsonExtract, SQLJsonKeys, SQLJsonLength, SQLJsonType, SQLJsonUnquote, SQLJsonValue, SQLJsonValueType, SQLLpad } from './SQLJsonExpressions.js';
-import { parseTable, SQLSelect } from './SQLSelect.js';
-import { SQLUpdate } from './SQLUpdate.js';
-import { ParseWhereArguments, SQLEmptyWhere, SQLWhere } from './SQLWhere.js';
-
-class StaticSQL {
-    wildcard(namespace?: string) {
-        return new SQLWildcardSelectExpression(namespace);
-    }
-
-    column(...args: SQLColumnExpressionParams): SQLColumnExpression {
-        return new SQLColumnExpression(...args);
-    }
-
-    parentColumn(column: string): SQLColumnExpression {
-        return new SQLColumnExpression(SQLParentNamespace, column);
-    }
-
-    jsonExtract(column: SQLExpression, path: string, asScalar = false): SQLJsonExtract {
-        return new SQLJsonExtract(column, asScalar ? new SQLScalar(path) : new SQLSafeValue(path));
-    }
-
-    jsonValue(column: SQLExpression, path: string, type?: SQLJsonValueType, asScalar = false): SQLJsonValue {
-        return new SQLJsonValue(column, type, asScalar ? new SQLScalar(path) : new SQLSafeValue(path));
-    }
-
-    jsonKeys(column: SQLExpression): SQLJsonKeys {
-        return new SQLJsonKeys(column);
-    }
-
-    jsonType(column: SQLExpression): SQLJsonType {
-        return new SQLJsonType(column);
-    }
-
-    lpad(column: SQLExpression, length: number, value: string): SQLLpad {
-        return new SQLLpad(column, new SQLSafeValue(length), new SQLSafeValue(value));
-    }
-
-    jsonUnquotedValue(column: SQLExpression, path: string): SQLJsonUnquote {
-        return new SQLJsonUnquote(new SQLJsonExtract(column, new SQLSafeValue(path)));
-    }
-
-    jsonLength(column: SQLExpression, path?: string): SQLJsonLength {
-        return new SQLJsonLength(column, path ? new SQLSafeValue(path) : undefined);
-    }
-
-    table(table: string, asNamespace?: string): SQLTableExpression {
-        return new SQLTableExpression(table, asNamespace);
-    }
-
-    jsonTable(expression: SQLExpression, asNamespace: string): SQLJSONTableExpression {
-        return new SQLJSONTableExpression(expression, asNamespace);
-    }
-
-    select(...columns: (SQLExpression | string)[]): InstanceType<typeof SQLSelect<SQLResultNamespacedRow>> {
-        if (columns.length === 0) {
-            return new SQLSelect(this.wildcard());
-        }
-        return new SQLSelect(...columns);
-    }
-
-    insert(tableName: SQLTableExpression | string): InstanceType<typeof SQLInsert> {
-        return new SQLInsert(tableName);
-    }
-
-    update(tableName: SQLTableExpression | string): InstanceType<typeof SQLUpdate> {
-        return new SQLUpdate(tableName);
-    }
-
-    assignment(key: SQLExpression | string, value: SQLExpression | SQLScalarValue): SQLAssignment {
-        return new SQLAssignment(typeof key === 'string' ? new SQLColumnExpression(key) : key, isSQLExpression(value) ? value : new SQLScalar(value));
-    }
-
-    where(...args: ParseWhereArguments): SQLWhere {
-        return new SQLEmptyWhere().and(...args);
-    }
-
-    whereNot(...args: ParseWhereArguments): SQLWhere {
-        return new SQLEmptyWhere().andNot(...args);
-    }
-
-    delete(): InstanceType<typeof SQLDelete> {
-        return new SQLDelete();
-    }
-
-    leftJoin(...args: Parameters<typeof parseTable>): SQLJoin {
-        return new SQLJoin(SQLJoinType.Left, parseTable(...args));
-    }
-
-    rightJoin(...args: Parameters<typeof parseTable>): SQLJoin {
-        return new SQLJoin(SQLJoinType.Right, parseTable(...args));
-    }
-
-    innerJoin(...args: Parameters<typeof parseTable>): SQLJoin {
-        return new SQLJoin(SQLJoinType.Inner, parseTable(...args));
-    }
-
-    join(...args: Parameters<typeof parseTable>): SQLJoin {
-        return new SQLJoin(SQLJoinType.Inner, parseTable(...args));
-    }
-
-    if(...args: ConstructorParameters<typeof SQLIf>): SQLIf {
-        return new SQLIf(...args);
-    }
-
-    coalesce(...args: ConstructorParameters<typeof SQLCoalesce>): SQLCoalesce {
-        return new SQLCoalesce(...args);
-    }
-
-    distinct(column?: SQLExpression): InstanceType<typeof SQLDistinct> {
-        if (!column) {
-            return new SQLDistinct(this.wildcard());
-        }
-        return new SQLDistinct(column);
-    }
-
-    isNull(column: SQLExpression): SQLIsNull {
-        return new SQLIsNull(column);
-    }
-}
-
-export const SQL = new StaticSQL();

package/src/SQLDelete.ts

@@ -1,73 +0,0 @@
-import { Database } from '@simonbackx/simple-database';
-import { SQLExpression, SQLExpressionOptions, SQLQuery, joinSQLQuery, normalizeSQLQuery } from './SQLExpression.js';
-import { SQLJoin } from './SQLJoin.js';
-import { SQLLogger } from './SQLLogger.js';
-import { Whereable } from './SQLWhere.js';
-
-class EmptyClass {}
-export class SQLDelete extends Whereable(EmptyClass) implements SQLExpression {
-    _from: SQLExpression;
-    _joins: (InstanceType<typeof SQLJoin>)[] = [];
-
-    clone(): this {
-        const c = new SQLDelete();
-        Object.assign(c, this);
-        return c as any;
-    }
-
-    from(table: SQLExpression): this {
-        this._from = table;
-        return this;
-    }
-
-    join(join: InstanceType<typeof SQLJoin>): this {
-        this._joins.push(join);
-        return this;
-    }
-
-    getSQL(options?: SQLExpressionOptions): SQLQuery {
-        const query: SQLQuery[] = [
-            'DELETE',
-        ];
-
-        options = options ?? {};
-        options.defaultNamespace = (this._from as any).namespace ?? (this._from as any).table ?? undefined;
-
-        query.push(
-            'FROM',
-        );
-
-        query.push(this._from.getSQL(options));
-
-        query.push(...this._joins.map(j => j.getSQL(options)));
-
-        // Where
-        if (this._where) {
-            const always = this._where.isAlways;
-            if (always === false) {
-                throw new Error('Cannot use SQLDelete with a where that is not always true');
-            }
-            else if (always === null) {
-                query.push('WHERE');
-                query.push(this._where.getSQL(options));
-            }
-        }
-
-        return joinSQLQuery(query, ' ');
-    }
-
-    async delete(): Promise<{ affectedRows: number }> {
-        if (this._where && this._where.isAlways === false) {
-            return { affectedRows: 0 };
-        }
-
-        const { query, params } = normalizeSQLQuery(this.getSQL());
-
-        const [rows] = await SQLLogger.log(Database.delete(query, params), query, params);
-        return rows;
-    }
-
-    async then(onFulfilled: (value: { affectedRows: number }) => any, onRejected: (reason: any) => any): Promise<any> {
-        return this.delete().then(onFulfilled, onRejected);
-    }
-}

package/src/SQLExpression.ts

@@ -1,34 +0,0 @@
-export type SQLExpressionOptions = {
-    defaultNamespace?: string;
-    parentNamespace?: string;
-};
-
-export type NormalizedSQLQuery = { query: string; params: any[] };
-export type SQLQuery = NormalizedSQLQuery | string;
-
-export function joinSQLQuery(queries: (SQLQuery | undefined | null)[], seperator?: string): NormalizedSQLQuery {
-    queries = queries.filter(q => q !== undefined && q !== null);
-    return {
-        query: queries.map(q => typeof q === 'string' ? q : q!.query).join(seperator ?? ''),
-        params: queries.flatMap(q => typeof q === 'string' ? [] : q!.params),
-    };
-}
-
-export function normalizeSQLQuery(q: SQLQuery): NormalizedSQLQuery {
-    return {
-        query: typeof q === 'string' ? q : q.query,
-        params: typeof q === 'string' ? [] : q.params,
-    };
-}
-
-export interface SQLExpression {
-    getSQL(options?: SQLExpressionOptions): SQLQuery;
-}
-
-export interface SQLNamedExpression extends SQLExpression {
-    getName(): string;
-}
-
-export function isSQLExpression(obj: unknown): obj is SQLExpression {
-    return typeof obj === 'object' && obj !== null && !!(obj as any).getSQL && typeof (obj as any).getSQL === 'function';
-}