velocious 1.0.107 → 1.0.109

package/dist/src/database/drivers/base.js

@@ -0,0 +1,654 @@
+// @ts-check
+/**
+ * @typedef {object} CreateIndexSqlArgs
+ * @property {Array<string | import("./../table-data/table-column.js").default>} columns
+ * @property {boolean} [ifNotExists]
+ * @property {string} [name]
+ * @property {boolean} [unique]
+ * @property {string} tableName
+ */
+/**
+ * @typedef {object} DropTableSqlArgsType
+ * @property {boolean} [cascade]
+ * @property {boolean} [ifExists]
+ */
+/**
+ * @typedef {object} DeleteSqlArgsType
+ * @property {string} tableName
+ * @property {{[key: string]: any}} conditions
+ */
+/**
+ * @typedef {object} InsertSqlArgsType
+ * @property {string[]} [columns]
+ * @property {{[key: string]: any}} [data]
+ * @property {boolean} [multiple]
+ * @property {string[]} [returnLastInsertedColumnNames]
+ * @property {Array<Array<any>>} [rows]
+ * @property {string} tableName
+ */
+/**
+ * @typedef {Record<string, any>} QueryRowType
+ * @typedef {Array<QueryRowType>} QueryResultType
+ */
+/**
+ * @typedef {object}UpdateSqlArgsType
+ * @property {object} conditions
+ * @property {object} data
+ * @property {string} tableName
+ */
+import { Logger } from "../../logger.js";
+import Query from "../query/index.js";
+import Handler from "../handler.js";
+import Mutex from "epic-locks/src/mutex.js";
+import strftime from "strftime";
+import UUID from "pure-uuid";
+import TableData from "../table-data/index.js";
+import TableColumn from "../table-data/table-column.js";
+import TableForeignKey from "../table-data/table-foreign-key.js";
+import wait from "awaitery/src/wait.js";
+export default class VelociousDatabaseDriversBase {
+    /** @type {number | undefined} */
+    idSeq = undefined;
+    /**
+     * @param {import("../../configuration-types.js").DatabaseConfigurationType} config
+     * @param {import("../../configuration.js").default} configuration
+     */
+    constructor(config, configuration) {
+        this._args = config;
+        this.configuration = configuration;
+        this.mutex = new Mutex(); // Can be used to lock this instance for exclusive use
+        this.logger = new Logger(this);
+        this._transactionsCount = 0;
+        this._transactionsActionsMutex = new Mutex();
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @param {string} referencedTableName
+     * @param {string} referencedColumnName
+     * @param {object} args
+     * @returns {Promise<void>}
+     */
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, args) {
+        const tableForeignKeyArgs = Object.assign({
+            columnName,
+            tableName,
+            referencedColumnName,
+            referencedTableName
+        }, args);
+        const tableForeignKey = new TableForeignKey(tableForeignKeyArgs);
+        const tableData = new TableData(tableName);
+        tableData.addForeignKey(tableForeignKey);
+        const alterTableSQLs = await this.alterTableSQLs(tableData);
+        for (const alterTableSQL of alterTableSQLs) {
+            await this.query(alterTableSQL);
+        }
+    }
+    /**
+     * @abstract
+     * @param {import("../table-data/index.js").default} _tableData
+     * @returns {Promise<string[]>}
+     */
+    alterTableSQLs(_tableData) {
+        throw new Error("alterTableSQLs not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    connect() {
+        throw new Error("'connect' not implemented");
+    }
+    /**
+     * @abstract
+     * @param {string} databaseName
+     * @param {object} [args]
+     * @param {boolean} [args.ifNotExists]
+     * @returns {string[]}
+     */
+    createDatabaseSql(databaseName, args) { throw new Error("'createDatabaseSql' not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @abstract
+     * @param {CreateIndexSqlArgs} indexData
+     * @returns {Promise<string[]>}
+     */
+    async createIndexSQLs(indexData) {
+        throw new Error("'createIndexSQLs' not implemented");
+    }
+    /**
+     * @param {import("../table-data/index.js").default} tableData
+     * @returns {Promise<void>}
+     */
+    async createTable(tableData) {
+        const sqls = await this.createTableSql(tableData);
+        for (const sql of sqls) {
+            await this.query(sql);
+        }
+    }
+    /**
+     * @abstract
+     * @param {import("../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async createTableSql(tableData) {
+        throw new Error("'createTableSql' not implemented");
+    }
+    /**
+     * @param {DeleteSqlArgsType} args
+     * @returns {Promise<void>}
+     */
+    async delete(args) {
+        const sql = this.deleteSql(args);
+        await this.query(sql);
+    }
+    /**
+     * @abstract
+     * @param {DeleteSqlArgsType} args
+     * @returns {string}
+     */
+    deleteSql(args) {
+        throw new Error(`'deleteSql' not implemented`);
+    }
+    /**
+     * @param {string} tableName
+     * @param {DropTableSqlArgsType} [args]
+     * @returns {Promise<void>}
+     */
+    async dropTable(tableName, args) {
+        const sqls = await this.dropTableSQLs(tableName, args);
+        for (const sql of sqls) {
+            await this.query(sql);
+        }
+    }
+    /**
+     * @abstract
+     * @param {string} tableName
+     * @param {DropTableSqlArgsType} [args]
+     * @returns {Promise<string[]>}
+     */
+    async dropTableSQLs(tableName, args) {
+        throw new Error("dropTableSQLs not implemented");
+    }
+    /**
+     * @abstract
+     * @param {any} value
+     * @returns {any}
+     */
+    escape(value) {
+        throw new Error("'escape' not implemented");
+    }
+    /**
+     * @returns {import("../../configuration-types.js").DatabaseConfigurationType}
+     */
+    getArgs() {
+        return this._args;
+    }
+    /**
+     * @returns {import("../../configuration.js").default}
+     */
+    getConfiguration() {
+        if (!this.configuration)
+            throw new Error("No configuration set");
+        return this.configuration;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    getIdSeq() {
+        return this.idSeq;
+    }
+    /**
+     * @abstract
+     * @returns {Promise<Array<import("./base-table.js").default>>}
+     */
+    getTables() {
+        throw new Error(`${this.constructor.name}#getTables not implemented`);
+    }
+    /**
+     * @param {string} name
+     * @param {object} [args]
+     * @param {boolean} args.throwError
+     * @returns {Promise<import("./base-table.js").default | undefined>}
+     */
+    async getTableByName(name, args) {
+        const tables = await this.getTables();
+        const tableNames = [];
+        let table;
+        for (const candidate of tables) {
+            const candidateName = candidate.getName();
+            if (candidateName == name) {
+                table = candidate;
+                break;
+            }
+            tableNames.push(candidateName);
+        }
+        if (!table && args?.throwError !== false)
+            throw new Error(`Couldn't find a table by that name "${name}" in: ${tableNames.join(", ")}`);
+        return table;
+    }
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    getType() {
+        throw new Error("'type' not implemented");
+    }
+    /**
+     * @param {InsertSqlArgsType} args
+     * @returns {Promise<void>}
+     */
+    async insert(args) {
+        const sql = this.insertSql(args);
+        await this.query(sql);
+    }
+    /**
+     * @abstract
+     * @param {string} tableName
+     * @param {Array<string>} columns
+     * @param {Array<Array<string>>} rows
+     * @returns {Promise<void>}
+     */
+    async insertMultiple(tableName, columns, rows) {
+        throw new Error("'insertMultiple' not implemented");
+    }
+    /**
+     * @abstract
+     * @param {InsertSqlArgsType} args
+     * @returns {string}
+     */
+    insertSql(args) {
+        throw new Error("'insertSql' not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {Promise<number>}
+     */
+    lastInsertID() {
+        throw new Error(`${this.constructor.name}#lastInsertID not implemented`);
+    }
+    /**
+     * @param {any} value
+     * @returns {any}
+     */
+    _convertValue(value) {
+        if (value instanceof Date) {
+            return strftime("%F %T.%L", value);
+        }
+        return value;
+    }
+    /**
+     * @abstract
+     * @returns {import("../query-parser/options.js").default}
+     */
+    options() {
+        throw new Error("'options' not implemented.");
+    }
+    /**
+     * @param {any} value
+     * @returns {number | string}
+     */
+    quote(value) {
+        if (typeof value == "number")
+            return value;
+        const escapedValue = this.escape(value);
+        const result = `"${escapedValue}"`;
+        return result;
+    }
+    /**
+     * @param {string} columnName
+     * @returns {string}
+     */
+    quoteColumn(columnName) {
+        return this.options().quoteColumnName(columnName);
+    }
+    /**
+     * @param {string} columnName
+     * @returns {string}
+     */
+    quoteIndex(columnName) {
+        return this.options().quoteIndexName(columnName);
+    }
+    /**
+     * @param {string} tableName
+     * @returns {string}
+     */
+    quoteTable(tableName) {
+        return this.options().quoteTableName(tableName);
+    }
+    /**
+     * @returns {Query}
+     */
+    newQuery() {
+        const handler = new Handler();
+        return new Query({
+            driver: this,
+            handler
+        });
+    }
+    /**
+     * @param {string} tableName
+     * @returns {Promise<QueryResultType>}
+     */
+    async select(tableName) {
+        const query = this.newQuery();
+        const sql = query
+            .from(tableName)
+            .toSql();
+        return await this.query(sql);
+    }
+    /**
+     * @param {number | undefined} newIdSeq
+     * @returns {void}
+     */
+    setIdSeq(newIdSeq) {
+        this.idSeq = newIdSeq;
+    }
+    /**
+     * @abstract
+     * @returns {boolean}
+     */
+    shouldSetAutoIncrementWhenPrimaryKey() {
+        throw new Error(`'shouldSetAutoIncrementWhenPrimaryKey' not implemented`);
+    }
+    /**
+     * @abstract
+     * @returns {boolean}
+     */
+    supportsInsertIntoReturning() { return false; }
+    /**
+     * @param {string} tableName
+     * @returns {Promise<boolean>}
+     */
+    async tableExists(tableName) {
+        const tables = await this.getTables();
+        const table = tables.find((table) => table.getName() == tableName);
+        if (table)
+            return true;
+        return false;
+    }
+    /**
+     * @param {() => Promise<void>} callback
+     * @returns {Promise<any>}
+     */
+    async transaction(callback) {
+        const savePointName = this.generateSavePointName();
+        let transactionStarted = false;
+        let savePointStarted = false;
+        if (this._transactionsCount == 0) {
+            this.logger.debug("Start transaction");
+            await this.startTransaction();
+            transactionStarted = true;
+        }
+        else {
+            this.logger.debug("Start savepoint", savePointName);
+            await this.startSavePoint(savePointName);
+            savePointStarted = true;
+        }
+        let result;
+        try {
+            result = await callback();
+            if (savePointStarted) {
+                this.logger.debug("Release savepoint", savePointName);
+                await this.releaseSavePoint(savePointName);
+            }
+            if (transactionStarted) {
+                this.logger.debug("Commit transaction");
+                await this.commitTransaction();
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.logger.debug("Transaction error", error.message);
+            }
+            else {
+                this.logger.debug("Transaction error", error);
+            }
+            if (savePointStarted) {
+                this.logger.debug("Rollback savepoint", savePointName);
+                await this.rollbackSavePoint(savePointName);
+            }
+            if (transactionStarted) {
+                this.logger.debug("Rollback transaction");
+                await this.rollbackTransaction();
+            }
+            throw error;
+        }
+        return result;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async startTransaction() {
+        await this._transactionsActionsMutex.sync(async () => {
+            await this._startTransactionAction();
+            this._transactionsCount++;
+        });
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async _startTransactionAction() {
+        await this.query("BEGIN TRANSACTION");
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async commitTransaction() {
+        await this._transactionsActionsMutex.sync(async () => {
+            await this._commitTransactionAction();
+            this._transactionsCount--;
+        });
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async _commitTransactionAction() {
+        await this.query("COMMIT");
+    }
+    /**
+     * @param {string} sql
+     * @returns {Promise<QueryResultType>}
+     */
+    async query(sql) {
+        let tries = 0;
+        while (tries < 5) {
+            tries++;
+            try {
+                return await this._queryActual(sql);
+            }
+            catch (error) {
+                if (error instanceof Error && tries < 5 && this.retryableDatabaseError(error)) {
+                    await wait(100);
+                    this.logger.warn(`Retrying query because failed with: ${error.stack}`);
+                    // Retry
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw new Error("'query' unexpected came here");
+    }
+    /**
+     * @abstract
+     * @param {string} sql
+     * @returns {Promise<QueryResultType>}
+     */
+    _queryActual(sql) {
+        throw new Error(`queryActual not implemented`);
+    }
+    /**
+     * @abstract
+     * @param {Query} _query
+     * @returns {string}
+     */
+    queryToSql(_query) { throw new Error("queryToSql not implemented"); } // eslint-disable-line no-unused-vars
+    /**
+     * @param {Error} _error
+     * @returns {boolean}
+     */
+    retryableDatabaseError(_error) {
+        return false;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async rollbackTransaction() {
+        await this._transactionsActionsMutex.sync(async () => {
+            await this._rollbackTransactionAction();
+            this._transactionsCount--;
+        });
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async _rollbackTransactionAction() {
+        await this.query("ROLLBACK");
+    }
+    /**
+     * @returns {string}
+     */
+    generateSavePointName() {
+        return `sp${new UUID(4).format().replaceAll("-", "")}`;
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async startSavePoint(savePointName) {
+        await this._transactionsActionsMutex.sync(async () => {
+            await this._startSavePointAction(savePointName);
+        });
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async _startSavePointAction(savePointName) {
+        await this.query(`SAVEPOINT ${savePointName}`);
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} oldColumnName
+     * @param {string} newColumnName
+     * @returns {Promise<void>}
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        const tableColumn = new TableColumn(oldColumnName);
+        tableColumn.setNewName(newColumnName);
+        const tableData = new TableData(tableName);
+        tableData.addColumn(tableColumn);
+        const alterTableSQLs = await this.alterTableSQLs(tableData);
+        for (const alterTableSQL of alterTableSQLs) {
+            await this.query(alterTableSQL);
+        }
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async releaseSavePoint(savePointName) {
+        await this._transactionsActionsMutex.sync(async () => {
+            await this._releaseSavePointAction(savePointName);
+        });
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async _releaseSavePointAction(savePointName) {
+        await this.query(`RELEASE SAVEPOINT ${savePointName}`);
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async rollbackSavePoint(savePointName) {
+        await this._transactionsActionsMutex.sync(async () => {
+            await this._rollbackSavePointAction(savePointName);
+        });
+    }
+    /**
+     * @param {string} savePointName
+     * @returns {Promise<void>}
+     */
+    async _rollbackSavePointAction(savePointName) {
+        await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async truncateAllTables() {
+        await this.withDisabledForeignKeys(async () => {
+            let tries = 0;
+            while (tries <= 5) {
+                tries++;
+                const tables = await this.getTables();
+                const truncateErrors = [];
+                for (const table of tables) {
+                    if (table.getName() != "schema_migrations") {
+                        try {
+                            await table.truncate({ cascade: true });
+                        }
+                        catch (error) {
+                            console.error(error);
+                            truncateErrors.push(error);
+                        }
+                    }
+                }
+                if (truncateErrors.length == 0) {
+                    break;
+                }
+                else if (tries <= 5) {
+                    // Retry
+                }
+                else {
+                    throw truncateErrors[0];
+                }
+            }
+        });
+    }
+    /**
+     * @param {UpdateSqlArgsType} args
+     * @returns {Promise<void>}
+     */
+    async update(args) {
+        const sql = this.updateSql(args);
+        await this.query(sql);
+    }
+    /**
+     * @abstract
+     * @param {UpdateSqlArgsType} args
+     * @returns {string}
+     */
+    updateSql(args) {
+        throw new Error("'disableForeignKeys' not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    disableForeignKeys() {
+        throw new Error("'disableForeignKeys' not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    enableForeignKeys() {
+        throw new Error("'enableForeignKeys' not implemented");
+    }
+    /**
+     * @param {function() : void} callback
+     * @returns {Promise<any>}
+     */
+    async withDisabledForeignKeys(callback) {
+        await this.disableForeignKeys();
+        try {
+            return await callback();
+        }
+        finally {
+            await this.enableForeignKeys();
+        }
+    }
+}

package/dist/src/database/drivers/mssql/column.d.ts

@@ -0,0 +1,13 @@
+export default class VelociousDatabaseDriversMssqlColumn extends BaseColumn {
+    /**
+     * @param {import("../base-table.js").default} table
+     * @param {Record<string, any>} data
+     */
+    constructor(table: import("../base-table.js").default, data: Record<string, any>);
+    data: Record<string, any>;
+    getMaxLength(): any;
+    getName(): any;
+    getType(): any;
+}
+import BaseColumn from "../base-column.js";
+//# sourceMappingURL=column.d.ts.map

package/dist/src/database/drivers/mssql/column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/column.js"],"names":[],"mappings":"AAMA;IACE;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,OAAO,QAClC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAM7B;IAFC,0BAAgB;IA2ClB,oBAAwE;IACxE,eAAsD;IAatD,eAAoD;CACrD;uBArEsB,mBAAmB"}