velocious 1.0.108 → 1.0.110

package/dist/src/database/query/index.js

@@ -0,0 +1,437 @@
+// @ts-check
+/**
+ * @typedef {{[key: string]: boolean | NestedPreloadRecord }} NestedPreloadRecord
+ * @typedef {string | string[] | import("./select-base.js").default | import("./select-base.js").default[]} SelectArgumentType
+ * @typedef {object | string} WhereArgumentType
+ */
+import FromPlain from "./from-plain.js";
+import { incorporate } from "incorporator";
+import * as inflection from "inflection";
+import { isPlainObject } from "is-plain-object";
+import JoinObject from "./join-object.js";
+import JoinPlain from "./join-plain.js";
+import { Logger } from "../../logger.js";
+import OrderPlain from "./order-plain.js";
+import Preloader from "./preloader.js";
+import RecordNotFoundError from "../record/record-not-found-error.js";
+import SelectBase from "./select-base.js";
+import SelectPlain from "./select-plain.js";
+import WhereHash from "./where-hash.js";
+import WherePlain from "./where-plain.js";
+import restArgsError from "../../utils/rest-args-error.js";
+/**
+ * A generic query over some model type.
+ */
+export default class VelociousDatabaseQuery {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {Array<import("./from-base.js").default>} [args.froms]
+     * @param {string[]} [args.groups]
+     * @param {Array<import("./join-base.js").default>} [args.joins]
+     * @param {import("../handler.js").default} args.handler
+     * @param {number | null} [args.limit]
+     * @param {typeof import("../record/index.js").default} [args.modelClass]
+     * @param {number | null} [args.offset]
+     * @param {Array<import("./order-base.js").default>} [args.orders]
+     * @param {number | null} [args.page]
+     * @param {number} [args.perPage]
+     * @param {NestedPreloadRecord} [args.preload]
+     * @param {Array<import("./select-base.js").default>} [args.selects]
+     * @param {Array<import("./where-base.js").default>} [args.wheres]
+     */
+    constructor({ driver, froms = [], groups = [], joins = [], handler, limit = null, modelClass, offset = null, orders = [], page = null, perPage, preload = {}, selects = [], wheres = [], ...restArgs }) {
+        if (!driver)
+            throw new Error("No driver given to query");
+        if (!handler)
+            throw new Error("No handler given to query");
+        restArgsError(restArgs);
+        this.driver = driver;
+        this.handler = handler;
+        this.logger = new Logger(this);
+        this.modelClass = modelClass;
+        this._froms = froms;
+        this._groups = groups;
+        this._joins = joins;
+        this._limit = limit;
+        this._offset = offset;
+        this._orders = orders;
+        this._page = page;
+        this._perPage = perPage;
+        this._preload = preload;
+        this._selects = selects;
+        /** @type {import("./where-base.js").default[]} */
+        this._wheres = wheres;
+    }
+    /**
+     * @returns {VelociousDatabaseQuery}
+     */
+    clone() {
+        const newQuery = new VelociousDatabaseQuery({
+            driver: this.driver,
+            froms: [...this._froms],
+            handler: this.handler.clone(),
+            groups: [...this._groups],
+            joins: [...this._joins],
+            limit: this._limit,
+            modelClass: this.modelClass,
+            offset: this._offset,
+            orders: [...this._orders],
+            page: this._page,
+            perPage: this._perPage,
+            preload: { ...this._preload },
+            selects: [...this._selects],
+            wheres: [...this._wheres]
+        });
+        return newQuery;
+    }
+    /**
+     * @returns {Promise<number>}
+     */
+    async count() {
+        // Generate count SQL
+        let sql = `COUNT(${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(this.getModelClass().primaryKey())})`;
+        if (this.driver.getType() == "pgsql")
+            sql += "::int";
+        sql += " AS count";
+        // Clone query and execute count
+        const countQuery = this.clone();
+        countQuery._selects = [];
+        countQuery.select(sql);
+        const results = /** @type {{ count: number }[]} */ (await countQuery._executeQuery());
+        // The query isn't grouped and a single result has been given
+        if (results.length == 1) {
+            return results[0].count;
+        }
+        // The query may be grouped and a lot of different counts a given
+        let countResult = 0;
+        for (const result of results) {
+            if (!("count" in result)) {
+                throw new Error("Invalid count result");
+            }
+            countResult += result.count;
+        }
+        return countResult;
+    }
+    /**
+     * @returns {import("./from-base.js").default[]}
+     */
+    getFroms() {
+        return this._froms;
+    }
+    /**
+     * @returns {string[]}
+     */
+    getGroups() {
+        return this._groups;
+    }
+    /**
+     * @returns {typeof import("../record/index.js").default}
+     */
+    getModelClass() {
+        if (!this.modelClass)
+            throw new Error("modelClass not set");
+        return this.modelClass;
+    }
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions() { return this.driver.options(); }
+    /**
+     * @returns {Array<import("./select-base.js").default>}
+     */
+    getSelects() { return this._selects; }
+    /**
+     * @returns {Promise<void>}
+     */
+    async destroyAll() {
+        const records = await this.toArray();
+        for (const record of records) {
+            await record.destroy();
+        }
+    }
+    /**
+     * @param {number|string} recordId
+     * @returns {Promise<import("../record/index.js").default>}
+     */
+    async find(recordId) {
+        /** @type {{[key: string]: number | string}} */
+        const conditions = {};
+        conditions[this.getModelClass().primaryKey()] = recordId;
+        const query = this.clone().where(conditions);
+        const record = await query.first();
+        if (!record) {
+            throw new RecordNotFoundError(`Couldn't find ${this.getModelClass().name} with '${this.getModelClass().primaryKey()}'=${recordId}`);
+        }
+        return record;
+    }
+    /**
+     * @param {{[key: string]: any}} conditions
+     * @returns {Promise<import("../record/index.js").default|null>}
+     */
+    async findBy(conditions) {
+        /** @type {{[key: string]: number | string}} */
+        const newConditions = {};
+        for (const key in conditions) {
+            const keyUnderscore = inflection.underscore(key);
+            newConditions[keyUnderscore] = conditions[key];
+        }
+        return await this.clone().where(newConditions).first();
+    }
+    /**
+     * @param {{[key: string]: any}} conditions
+     * @param {function() : void} callback
+     * @returns {Promise<import("../record/index.js").default>}
+     */
+    async findOrCreateBy(conditions, callback) {
+        const record = await this.findOrInitializeBy(conditions, callback);
+        if (record.isNewRecord()) {
+            await record.save();
+        }
+        return record;
+    }
+    /**
+     * @param {{[key: string]: any}} conditions
+     * @returns {Promise<import("../record/index.js").default>}
+     */
+    async findByOrFail(conditions) {
+        /** @type {{[key: string]: number | string}} */
+        const newConditions = {};
+        for (const key in conditions) {
+            const keyUnderscore = inflection.underscore(key);
+            newConditions[keyUnderscore] = conditions[key];
+        }
+        const model = await this.clone().where(newConditions).first();
+        if (!model) {
+            throw new Error("Record not found");
+        }
+        return model;
+    }
+    /**
+     * @param {object} conditions
+     * @param {function(import("../record/index.js").default) : void} callback
+     * @returns {Promise<import("../record/index.js").default>}
+     */
+    async findOrInitializeBy(conditions, callback) {
+        const record = await this.findBy(conditions);
+        if (record)
+            return record;
+        const ModelClass = this.getModelClass();
+        const newRecord = new ModelClass(conditions);
+        if (callback) {
+            callback(newRecord);
+        }
+        return newRecord;
+    }
+    /**
+     * @returns {Promise<import("../record/index.js").default>}
+     */
+    async first() {
+        const newQuery = this.clone().limit(1).reorder(`${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(this.getModelClass().orderableColumn())}`);
+        const results = await newQuery.toArray();
+        return results[0];
+    }
+    /**
+     * @param {string|import("./from-base.js").default} from
+     * @returns {this}
+     */
+    from(from) {
+        if (typeof from == "string")
+            from = new FromPlain(from);
+        this._froms.push(from);
+        return this;
+    }
+    /**
+     * @param {string} group
+     * @returns {this}
+     */
+    group(group) {
+        this._groups.push(group);
+        return this;
+    }
+    /**
+     * @param {string|{[key: string]: any}} join
+     * @returns {this}
+     */
+    joins(join) {
+        if (typeof join == "string") {
+            this._joins.push(new JoinPlain(join));
+        }
+        else if (isPlainObject(join)) {
+            this._joins.push(new JoinObject(join));
+        }
+        else {
+            throw new Error(`Unknown type of join: ${typeof join}`);
+        }
+        return this;
+    }
+    /**
+     * @returns {Promise<import("../record/index.js").default>}
+     */
+    async last() {
+        const primaryKey = this.getModelClass().primaryKey();
+        const tableName = this.getModelClass().tableName();
+        const results = await this.clone().reorder(`${this.driver.quoteTable(tableName)}.${this.driver.quoteColumn(primaryKey)} DESC`).limit(1).toArray();
+        return results[0];
+    }
+    /**
+     * @param {number} value
+     * @returns {this}
+     */
+    limit(value) {
+        this._limit = value;
+        return this;
+    }
+    /**
+     * @param {number} value
+     * @returns {this}
+     */
+    offset(value) {
+        this._offset = value;
+        return this;
+    }
+    /**
+     * @param {string | number} order
+     * @returns {this}
+     */
+    order(order) {
+        if (typeof order == "string") {
+            this._orders.push(new OrderPlain(this, order));
+        }
+        else if (typeof order == "number") {
+            this._orders.push(new OrderPlain(this, `${order}`));
+        }
+        else {
+            throw new Error(`Unknown order type: ${typeof order}`);
+        }
+        return this;
+    }
+    /**
+     * @param {number} pageNumber
+     * @returns {this}
+     */
+    page(pageNumber) {
+        const perPage = this._perPage || 30;
+        const offset = (pageNumber - 1) * perPage;
+        const limit = perPage;
+        this._page = pageNumber;
+        this.limit(limit);
+        this.offset(offset);
+        return this;
+    }
+    /**
+     * @param {number} perPage
+     * @returns {this}
+     */
+    perPage(perPage) {
+        this._perPage = perPage;
+        return this;
+    }
+    /**
+     * @param {NestedPreloadRecord} data
+     * @returns {this}
+     */
+    preload(data) {
+        incorporate(this._preload, data);
+        return this;
+    }
+    /**
+     * @param {string | number} order
+     * @returns {this}
+     */
+    reorder(order) {
+        this._orders = [];
+        this.order(order);
+        return this;
+    }
+    /**
+     * @returns {this}
+     */
+    reverseOrder() {
+        for (const order of this._orders) {
+            order.setReverseOrder(true);
+        }
+        return this;
+    }
+    /**
+     * @param {SelectArgumentType} select
+     * @returns {this}
+     */
+    select(select) {
+        if (Array.isArray(select)) {
+            for (const selectInArray of select) {
+                this.select(selectInArray);
+            }
+            return this;
+        }
+        if (typeof select == "string") {
+            this._selects.push(new SelectPlain(select));
+        }
+        else if (select instanceof SelectBase) {
+            this._selects.push(select);
+        }
+        else {
+            throw new Error(`Invalid select type: ${typeof select}`);
+        }
+        return this;
+    }
+    /**
+     * @returns {Promise<Array<object>>} Array of results from the database
+     */
+    async _executeQuery() {
+        const sql = this.toSql();
+        const results = await this.driver.query(sql);
+        this.logger.debug(() => ["SQL:", sql]);
+        return results;
+    }
+    /**
+     * @returns {Promise<Array<object>>} Array of results from the database
+     */
+    async results() {
+        return await this._executeQuery();
+    }
+    /**
+     * Converts query results to array of model instances
+     * @returns {Promise<Array<import("../record/index.js").default>>}
+     */
+    async toArray() {
+        const models = [];
+        const results = await this.results();
+        for (const result of results) {
+            const ModelClass = this.getModelClass();
+            const model = new ModelClass();
+            model.loadExistingRecord(result);
+            models.push(model);
+        }
+        if (Object.keys(this._preload).length > 0 && models.length > 0) {
+            const preloader = new Preloader({
+                modelClass: this.modelClass,
+                models,
+                preload: this._preload
+            });
+            await preloader.run();
+        }
+        return models;
+    }
+    /**
+     * Generates SQL string representing this query
+     * @returns {string} SQL string representing this query
+     */
+    toSql() { return this.driver.queryToSql(this); }
+    /**
+     * @param {WhereArgumentType} where
+     * @returns {VelociousDatabaseQuery} This query instance
+     */
+    where(where) {
+        if (typeof where == "string") {
+            this._wheres.push(new WherePlain(this, where));
+        }
+        else if (typeof where == "object" && (where.constructor.name == "object" || where.constructor.name == "Object")) {
+            this._wheres.push(new WhereHash(this, where));
+        }
+        else {
+            throw new Error(`Invalid type of where: ${typeof where} (${where.constructor.name})`);
+        }
+        return this;
+    }
+}

package/dist/src/database/query/insert-base.d.ts

@@ -0,0 +1,41 @@
+export default class VelociousDatabaseQueryInsertBase {
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} [args.data]
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {string} args.tableName
+     * @param {Array<string>} [args.columns]
+     * @param {boolean} [args.multiple]
+     * @param {string[]} [args.returnLastInsertedColumnNames]
+     * @param {Array<Array<string>>} [args.rows]
+     */
+    constructor({ columns, data, driver, multiple, tableName, returnLastInsertedColumnNames, rows, ...restArgs }: {
+        data?: Record<string, any>;
+        driver: import("../drivers/base.js").default;
+        tableName: string;
+        columns?: Array<string>;
+        multiple?: boolean;
+        returnLastInsertedColumnNames?: string[];
+        rows?: Array<Array<string>>;
+    });
+    columns: string[];
+    data: Record<string, any>;
+    driver: import("../drivers/base.js").default;
+    multiple: boolean;
+    returnLastInsertedColumnNames: string[];
+    rows: string[][];
+    tableName: string;
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions(): import("../query-parser/options.js").default;
+    /**
+     * @returns {string} SQL statement
+     */
+    toSql(): string;
+    /**
+     * @param {any[]} data
+     */
+    _valuesSql(data: any[]): string;
+}
+//# sourceMappingURL=insert-base.d.ts.map

package/dist/src/database/query/insert-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/insert-base.js"],"names":[],"mappings":"AAIA;IACE;;;;;;;;;OASG;IACH,8GARG;QAAmC,IAAI,GAA/B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACwB,MAAM,EAAjD,OAAO,oBAAoB,EAAE,OAAO;QACvB,SAAS,EAAtB,MAAM;QACe,OAAO,GAA5B,KAAK,CAAC,MAAM,CAAC;QACE,QAAQ,GAAvB,OAAO;QACS,6BAA6B,GAA7C,MAAM,EAAE;QACoB,IAAI,GAAhC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;KAAa,EAe3C;IAPC,kBAAsB;IACtB,0BAAgB;IAChB,6CAAoB;IACpB,kBAAwB;IACxB,wCAAkE;IAClE,iBAAgB;IAChB,kBAA0B;IAG5B;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED;;OAEG;IACH,SAFa,MAAM,CAiGlB;IAED;;OAEG;IACH,iBAFW,GAAG,EAAE,UAgBf;CACF"}

package/dist/src/database/query/insert-base.js

@@ -0,0 +1,135 @@
+// @ts-check
+import restArgsError from "../../utils/rest-args-error.js";
+export default class VelociousDatabaseQueryInsertBase {
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} [args.data]
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {string} args.tableName
+     * @param {Array<string>} [args.columns]
+     * @param {boolean} [args.multiple]
+     * @param {string[]} [args.returnLastInsertedColumnNames]
+     * @param {Array<Array<string>>} [args.rows]
+     */
+    constructor({ columns, data, driver, multiple, tableName, returnLastInsertedColumnNames, rows, ...restArgs }) {
+        if (!driver)
+            throw new Error("No driver given to insert base");
+        if (!tableName)
+            throw new Error(`Invalid table name given to insert base: ${tableName}`);
+        restArgsError(restArgs);
+        this.columns = columns;
+        this.data = data;
+        this.driver = driver;
+        this.multiple = multiple;
+        this.returnLastInsertedColumnNames = returnLastInsertedColumnNames;
+        this.rows = rows;
+        this.tableName = tableName;
+    }
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions() {
+        return this.driver.options();
+    }
+    /**
+     * @returns {string} SQL statement
+     */
+    toSql() {
+        const { driver } = this;
+        let sql = `INSERT INTO ${driver.quoteTable(this.tableName)}`;
+        let count = 0;
+        let columns, lastInsertedSQL;
+        if (this.returnLastInsertedColumnNames) {
+            if (driver.getType() == "mssql") {
+                lastInsertedSQL = ` OUTPUT `;
+                for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {
+                    const columnName = this.returnLastInsertedColumnNames[i];
+                    if (i > 0) {
+                        lastInsertedSQL += ", ";
+                    }
+                    lastInsertedSQL += ` INSERTED.${driver.quoteColumn(columnName)}`;
+                }
+                if (this.data && Object.keys(this.data).length <= 0) {
+                    sql += lastInsertedSQL;
+                }
+            }
+            else if (driver.getType() == "mysql" || driver.getType() == "pgsql" || (driver.getType() == "sqlite" && driver.supportsInsertIntoReturning())) {
+                lastInsertedSQL = " RETURNING ";
+                for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {
+                    const columnName = this.returnLastInsertedColumnNames[i];
+                    if (i > 0) {
+                        lastInsertedSQL += ", ";
+                    }
+                    lastInsertedSQL += ` ${driver.quoteColumn(columnName)}`;
+                }
+            }
+        }
+        if (this.columns && this.rows) {
+            columns = this.columns;
+        }
+        else if (this.data) {
+            columns = Object.keys(this.data);
+        }
+        else {
+            throw new Error("Neither 'column' and 'rows' or data was given");
+        }
+        if (columns.length > 0) {
+            sql += " (";
+            for (const columnName of columns) {
+                if (count > 0)
+                    sql += ", ";
+                sql += driver.quoteColumn(columnName);
+                count++;
+            }
+            sql += ")";
+        }
+        if (this.returnLastInsertedColumnNames && driver.getType() == "mssql" && this.data && Object.keys(this.data).length > 0) {
+            sql += lastInsertedSQL;
+        }
+        if (this.columns && this.rows) {
+            if (this.rows.length > 0) {
+                sql += " VALUES ";
+            }
+            let count = 0;
+            for (const row of this.rows) {
+                if (count >= 1)
+                    sql += ", ";
+                count++;
+                sql += this._valuesSql(row);
+            }
+        }
+        else {
+            if (this.data && Object.keys(this.data).length > 0) {
+                sql += " VALUES ";
+                sql += this._valuesSql(Object.values(this.data));
+            }
+            else if (driver.getType() == "sqlite" || driver.getType() == "mssql") {
+                sql += " DEFAULT VALUES";
+            }
+            else if (driver.getType() == "mysql") {
+                sql += " () VALUES ()";
+            }
+        }
+        if (this.returnLastInsertedColumnNames) {
+            if (driver.getType() == "pgsql" || driver.getType() == "mysql" || (driver.getType() == "sqlite" && driver.supportsInsertIntoReturning())) {
+                sql += lastInsertedSQL;
+            }
+        }
+        return sql;
+    }
+    /**
+     * @param {any[]} data
+     */
+    _valuesSql(data) {
+        let count = 0;
+        let sql = "(";
+        for (const value of data) {
+            if (count > 0)
+                sql += ", ";
+            sql += this.getOptions().quote(value);
+            count++;
+        }
+        sql += ")";
+        return sql;
+    }
+}

package/dist/src/database/query/join-base.d.ts

@@ -0,0 +1,22 @@
+export default class VelociousDatabaseQueryJoinBase {
+    pretty: boolean;
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions(): import("../query-parser/options.js").default;
+    /**
+     * @returns {import("./index.js").default}
+     */
+    getQuery(): import("./index.js").default;
+    /**
+     * @param {boolean} value
+     */
+    setPretty(value: boolean): void;
+    /**
+     * @param {import("./index.js").default} query
+     */
+    setQuery(query: import("./index.js").default): void;
+    query: import("./index.js").default;
+    toSql(): void;
+}
+//# sourceMappingURL=join-base.d.ts.map

package/dist/src/database/query/join-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/join-base.js"],"names":[],"mappings":"AAEA;IACE,gBAAc;IAEd;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED;;OAEG;IACH,YAFa,OAAO,YAAY,EAAE,OAAO,CAMxC;IAED;;OAEG;IACH,iBAFW,OAAO,QAIjB;IAED;;OAEG;IACH,gBAFW,OAAO,YAAY,EAAE,OAAO,QAItC;IADC,oCAAkB;IAGpB,cAEC;CACF"}

package/dist/src/database/query/join-base.js

@@ -0,0 +1,33 @@
+// @ts-check
+export default class VelociousDatabaseQueryJoinBase {
+    pretty = false;
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions() {
+        return this.getQuery().driver.options();
+    }
+    /**
+     * @returns {import("./index.js").default}
+     */
+    getQuery() {
+        if (!this.query)
+            throw new Error("'query' hasn't been set");
+        return this.query;
+    }
+    /**
+     * @param {boolean} value
+     */
+    setPretty(value) {
+        this.pretty = value;
+    }
+    /**
+     * @param {import("./index.js").default} query
+     */
+    setQuery(query) {
+        this.query = query;
+    }
+    toSql() {
+        throw new Error("'toSql' wasn't implemented");
+    }
+}