velocious 1.0.107 → 1.0.109

package/dist/src/database/drivers/mssql/sql/delete.js

@@ -0,0 +1,16 @@
+import DeleteBase from "../../../query/delete-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlDelete extends DeleteBase {
+    toSql() {
+        let sql = `DELETE FROM ${this.getOptions().quoteTableName(this.tableName)} WHERE `;
+        let count = 0;
+        for (let columnName in this.conditions) {
+            if (count > 0)
+                sql += " AND ";
+            sql += this.getOptions().quoteColumnName(columnName);
+            sql += " = ";
+            sql += this.getOptions().quote(this.conditions[columnName]);
+            count++;
+        }
+        return sql;
+    }
+}

package/dist/src/database/drivers/mssql/sql/drop-table.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlDropTable extends DropTableBase {
+}
+import DropTableBase from "../../../query/drop-table-base.js";
+//# sourceMappingURL=drop-table.d.ts.map

package/dist/src/database/drivers/mssql/sql/drop-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-table.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/drop-table.js"],"names":[],"mappings":"AAEA;CACC;0BAHyB,mCAAmC"}

package/dist/src/database/drivers/mssql/sql/drop-table.js

@@ -0,0 +1,3 @@
+import DropTableBase from "../../../query/drop-table-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlDropTable extends DropTableBase {
+}

package/dist/src/database/drivers/mssql/sql/insert.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlInsert extends InsertBase {
+}
+import InsertBase from "../../../query/insert-base.js";
+//# sourceMappingURL=insert.d.ts.map

package/dist/src/database/drivers/mssql/sql/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/insert.js"],"names":[],"mappings":"AAEA;CACC;uBAHsB,+BAA+B"}

package/dist/src/database/drivers/mssql/sql/insert.js

@@ -0,0 +1,3 @@
+import InsertBase from "../../../query/insert-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlInsert extends InsertBase {
+}

package/dist/src/database/drivers/mssql/sql/update.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseConnectionDriversMssqlSqlUpdate extends UpdateBase {
+    toSql(): string;
+}
+import UpdateBase from "../../../query/update-base.js";
+//# sourceMappingURL=update.d.ts.map

package/dist/src/database/drivers/mssql/sql/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../src/database/drivers/mssql/sql/update.js"],"names":[],"mappings":"AAEA;IACE,gBA0BC;CACF;uBA9BsB,+BAA+B"}

package/dist/src/database/drivers/mssql/sql/update.js

@@ -0,0 +1,26 @@
+import UpdateBase from "../../../query/update-base.js";
+export default class VelociousDatabaseConnectionDriversMssqlSqlUpdate extends UpdateBase {
+    toSql() {
+        let sql = `UPDATE ${this.getOptions().quoteTableName(this.tableName)} SET `;
+        let count = 0;
+        for (let columnName in this.data) {
+            if (count > 0)
+                sql += ", ";
+            sql += this.getOptions().quoteColumnName(columnName);
+            sql += " = ";
+            sql += this.getOptions().quote(this.data[columnName]);
+            count++;
+        }
+        sql += " WHERE ";
+        count = 0;
+        for (let columnName in this.conditions) {
+            if (count > 0)
+                sql += " AND ";
+            sql += this.getOptions().quoteColumnName(columnName);
+            sql += " = ";
+            sql += this.getOptions().quote(this.conditions[columnName]);
+            count++;
+        }
+        return sql;
+    }
+}

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

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseDriversMssqlTable extends BaseTable {
+    /**
+     * @param {import("../base.js").default} driver
+     * @param {Record<string, any>} data
+     */
+    constructor(driver: import("../base.js").default, data: Record<string, any>);
+    data: Record<string, any>;
+    getColumns(): Promise<Column[]>;
+    getForeignKeys(): Promise<ForeignKey[]>;
+    getName(): any;
+}
+import BaseTable from "../base-table.js";
+import Column from "./column.js";
+import ForeignKey from "./foreign-key.js";
+//# sourceMappingURL=table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/table.js"],"names":[],"mappings":"AAQA;IACE;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,OAAO,QAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAM7B;IAFC,0BAAgB;IAIlB,gCAiBC;IAED,wCAoCC;IAqCD,eAEC;CAkBF;sBAjIqB,kBAAkB;mBACrB,aAAa;uBAGT,kBAAkB"}

package/dist/src/database/drivers/mssql/table.js

@@ -0,0 +1,116 @@
+// @ts-check
+import BaseTable from "../base-table.js";
+import Column from "./column.js";
+import ColumnsIndex from "./columns-index.js";
+import { digg } from "diggerize";
+import ForeignKey from "./foreign-key.js";
+export default class VelociousDatabaseDriversMssqlTable extends BaseTable {
+    /**
+     * @param {import("../base.js").default} driver
+     * @param {Record<string, any>} data
+     */
+    constructor(driver, data) {
+        super();
+        this.data = data;
+        this.driver = driver;
+    }
+    async getColumns() {
+        const result = await this.driver.query(`
+      SELECT
+        *,
+        COLUMNPROPERTY(object_id(TABLE_SCHEMA + '.' + TABLE_NAME), COLUMN_NAME, 'IsIdentity') AS isIdentity
+      FROM [INFORMATION_SCHEMA].[COLUMNS]
+      WHERE [TABLE_NAME] = ${this.driver.quote(this.getName())}
+    `);
+        const columns = [];
+        for (const data of result) {
+            const column = new Column(this, data);
+            columns.push(column);
+        }
+        return columns;
+    }
+    async getForeignKeys() {
+        const sql = `
+      SELECT
+          fk.name AS ForeignKeyName,
+          tp.name AS ParentTable,
+          ref.name AS ReferencedTable,
+          cp.name AS ParentColumn,
+          cref.name AS ReferencedColumn,
+          tp.name AS TableName
+      FROM sys.foreign_keys fk
+      INNER JOIN sys.foreign_key_columns fkc
+          ON fkc.constraint_object_id = fk.object_id
+      INNER JOIN sys.tables tp
+          ON fkc.parent_object_id = tp.object_id
+      INNER JOIN sys.columns cp
+          ON fkc.parent_object_id = cp.object_id
+          AND fkc.parent_column_id = cp.column_id
+      INNER JOIN sys.tables ref
+          ON fkc.referenced_object_id = ref.object_id
+      INNER JOIN sys.columns cref
+          ON fkc.referenced_object_id = cref.object_id
+          AND fkc.referenced_column_id = cref.column_id
+      WHERE tp.name = ${this.driver.quote(this.getName())}
+      ORDER BY ForeignKeyName, ParentTable, ReferencedTable;
+    `;
+        const foreignKeyRows = await this.driver.query(sql);
+        const foreignKeys = [];
+        for (const foreignKeyRow of foreignKeyRows) {
+            const foreignKey = new ForeignKey(foreignKeyRow);
+            foreignKeys.push(foreignKey);
+        }
+        return foreignKeys;
+    }
+    async getIndexes() {
+        const options = this.getOptions();
+        const sql = `
+      SELECT
+        sys.tables.name AS TableName,
+        sys.columns.name AS ColumnName,
+        sys.indexes.name AS index_name,
+        sys.indexes.type_desc AS IndexType,
+        sys.index_columns.is_included_column AS IsIncludedColumn,
+        sys.indexes.is_unique,
+        sys.indexes.is_primary_key,
+        sys.indexes.is_unique_constraint
+      FROM sys.indexes
+      INNER JOIN sys.index_columns ON sys.indexes.object_id = sys.index_columns.object_id AND sys.indexes.index_id = sys.index_columns.index_id
+      INNER JOIN sys.columns ON sys.index_columns.object_id = sys.columns.object_id AND sys.index_columns.column_id = sys.columns.column_id
+      INNER JOIN sys.tables ON sys.indexes.object_id = sys.tables.object_id
+      WHERE
+        sys.tables.name = ${options.quote(this.getName())}
+      ORDER BY
+        sys.indexes.name,
+        sys.index_columns.key_ordinal
+    `;
+        const rows = await this.getDriver().query(sql);
+        const indexes = [];
+        for (const row of rows) {
+            const index = new ColumnsIndex(this, row);
+            indexes.push(index);
+        }
+        return indexes;
+    }
+    getName() {
+        return digg(this.data, "TABLE_NAME");
+    }
+    /**
+     * @param {{cascade: boolean}} [args]
+     * @returns {Promise<Array<Record<string, any>>>}
+     */
+    async truncate(args) {
+        try {
+            return await this.getDriver().query(`TRUNCATE TABLE ${this.getOptions().quoteTableName(this.getName())}`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith("Query failed 'Cannot truncate table")) {
+                // Truncate table is really buggy for some reason - fall back to delete all rows instead
+                return await this.getDriver().query(`DELETE FROM ${this.getOptions().quoteTableName(this.getName())}`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+export default class VelociousDatabaseDriversMysqlColumn 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>;
+    getAutoIncrement(): any;
+    getName(): any;
+    getType(): any;
+}
+import BaseColumn from "../base-column.js";
+//# sourceMappingURL=column.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/column.js"],"names":[],"mappings":"AAMA;IACE;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,OAAO,QAClC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAM7B;IAFC,0BAAgB;IAIlB,wBAAoF;IAwDpF,eAAgD;IAgBhD,eAcC;CACF;uBAtGsB,mBAAmB"}

package/dist/src/database/drivers/mysql/column.js

@@ -0,0 +1,87 @@
+// @ts-check
+import BaseColumn from "../base-column.js";
+import ColumnsIndex from "./columns-index.js";
+import { digg } from "diggerize";
+export default class VelociousDatabaseDriversMysqlColumn extends BaseColumn {
+    /**
+     * @param {import("../base-table.js").default} table
+     * @param {Record<string, any>} data
+     */
+    constructor(table, data) {
+        super();
+        this.data = data;
+        this.table = table;
+    }
+    getAutoIncrement() { return digg(this, "data", "Extra").includes("auto_increment"); }
+    async getIndexes() {
+        const options = this.getOptions();
+        const sql = `
+      SELECT
+        TABLE_SCHEMA,
+        TABLE_NAME,
+        INDEX_NAME AS index_name,
+        COLUMN_NAME,
+        SEQ_IN_INDEX,
+        NON_UNIQUE,
+        INDEX_TYPE
+      FROM INFORMATION_SCHEMA.STATISTICS
+      WHERE
+        TABLE_SCHEMA = DATABASE() AND
+        TABLE_NAME = ${options.quote(this.table.getName())} AND
+        COLUMN_NAME = ${options.quote(this.getName())}
+    `;
+        const indexesRows = await this.getDriver().query(sql);
+        const indexes = [];
+        for (const indexRow of indexesRows) {
+            if (indexRow.NON_UNIQUE == 1) {
+                indexRow.is_unique = false;
+            }
+            else {
+                indexRow.is_unique = true;
+            }
+            if (indexRow.index_name == "PRIMARY") {
+                indexRow.is_primary_key = true;
+            }
+            else {
+                indexRow.is_primary_key = false;
+            }
+            const index = new ColumnsIndex(this.getTable(), indexRow);
+            indexes.push(index);
+        }
+        return indexes;
+    }
+    getDefault() { return digg(this, "data", "Default"); }
+    getMaxLength() {
+        const type = digg(this, "data", "Type");
+        const match = type.match(/\((\d+)\)$/);
+        if (match) {
+            const maxLength = parseInt(match[1]);
+            return maxLength;
+        }
+    }
+    getName() { return digg(this, "data", "Field"); }
+    getNull() {
+        const nullValue = digg(this, "data", "Null");
+        if (nullValue == "NO") {
+            return false;
+        }
+        else if (nullValue == "YES") {
+            return true;
+        }
+        else {
+            throw new Error(`Unknown null value: ${nullValue}`);
+        }
+    }
+    getPrimaryKey() { return digg(this, "data", "Key") == "PRI"; }
+    getType() {
+        const type = digg(this, "data", "Type");
+        if (type.match(/^[a-z]+$/)) {
+            return type;
+        }
+        const match = type.match(/^(.+)\((\d+)\)$/);
+        if (!match)
+            throw new Error(`Couldn't match column type from: ${type}`);
+        const columnType = match[1];
+        return columnType;
+    }
+}

package/dist/src/database/drivers/mysql/columns-index.d.ts

@@ -0,0 +1,4 @@
+export default class VelociousDatabaseDriversMysqlColumnsIndex extends BaseColumnsIndex {
+}
+import BaseColumnsIndex from "../base-columns-index.js";
+//# sourceMappingURL=columns-index.d.ts.map

package/dist/src/database/drivers/mysql/columns-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns-index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/columns-index.js"],"names":[],"mappings":"AAIA;CACC;6BAH4B,0BAA0B"}

package/dist/src/database/drivers/mysql/columns-index.js

@@ -0,0 +1,4 @@
+// @ts-check
+import BaseColumnsIndex from "../base-columns-index.js";
+export default class VelociousDatabaseDriversMysqlColumnsIndex extends BaseColumnsIndex {
+}

package/dist/src/database/drivers/mysql/foreign-key.d.ts

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseDriversMysqlForeignKey extends BaseForeignKey {
+    getColumnName(): any;
+    getName(): any;
+    getTableName(): any;
+    getReferencedColumnName(): any;
+    getReferencedTableName(): any;
+}
+import BaseForeignKey from "../base-foreign-key.js";
+//# sourceMappingURL=foreign-key.d.ts.map

package/dist/src/database/drivers/mysql/foreign-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/foreign-key.js"],"names":[],"mappings":"AAKA;IACE,qBAA4D;IAC5D,eAA0D;IAC1D,oBAA0D;IAC1D,+BAAiF;IACjF,8BAA+E;CAChF;2BAT0B,wBAAwB"}

package/dist/src/database/drivers/mysql/foreign-key.js

@@ -0,0 +1,10 @@
+// @ts-check
+import BaseForeignKey from "../base-foreign-key.js";
+import { digg } from "diggerize";
+export default class VelociousDatabaseDriversMysqlForeignKey extends BaseForeignKey {
+    getColumnName() { return digg(this, "data", "COLUMN_NAME"); }
+    getName() { return digg(this, "data", "CONSTRAINT_NAME"); }
+    getTableName() { return digg(this, "data", "TABLE_NAME"); }
+    getReferencedColumnName() { return digg(this, "data", "REFERENCED_COLUMN_NAME"); }
+    getReferencedTableName() { return digg(this, "data", "REFERENCED_TABLE_NAME"); }
+}

package/dist/src/database/drivers/mysql/index.d.ts

@@ -0,0 +1,30 @@
+export default class VelociousDatabaseDriversMysql extends Base {
+    pool: any;
+    /** @param {Error} error */
+    onPoolError: (error: Error) => void;
+    /**
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+    /**
+     * @returns {Record<string, any>}
+     */
+    connectArgs(): Record<string, any>;
+    /**
+     * @returns {Promise<string>}
+     */
+    currentDatabase(): Promise<string>;
+    /**
+     * @returns {string}
+     */
+    primaryKeyType(): string;
+    /**
+     * @param {string} value
+     * @returns {string}
+     */
+    quote(value: string): string;
+    _options: Options;
+}
+import Base from "../base.js";
+import Options from "./options.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/database/drivers/mysql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/index.js"],"names":[],"mappings":"AAkBA;IAKI,UAAqF;IAIvF,2BAA2B;IAC3B,cAAe,OADH,KACQ,UAEnB;IAED;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;OAEG;IACH,eAFa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAgB/B;IAgDD;;OAEG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IAiCD;;OAEG;IACH,kBAFa,MAAM,CAEiB;IA4CpC;;;OAGG;IACH,aAHW,MAAM,GACJ,MAAM,CAMlB;IAqDqB,kBAA2C;CAqBlE;iBA/QgB,YAAY;oBAQT,cAAc"}

package/dist/src/database/drivers/mysql/index.js

@@ -0,0 +1,234 @@
+// @ts-check
+import AlterTable from "./sql/alter-table.js";
+import Base from "../base.js";
+import CreateDatabase from "./sql/create-database.js";
+import CreateIndex from "./sql/create-index.js";
+import CreateTable from "./sql/create-table.js";
+import Delete from "./sql/delete.js";
+import { digg } from "diggerize";
+import DropTable from "./sql/drop-table.js";
+import Insert from "./sql/insert.js";
+import Options from "./options.js";
+import mysql from "mysql";
+import query from "./query.js";
+import QueryParser from "./query-parser.js";
+import Table from "./table.js";
+import Update from "./sql/update.js";
+export default class VelociousDatabaseDriversMysql extends Base {
+    /**
+     * @returns {Promise<void>}
+     */
+    async connect() {
+        this.pool = mysql.createPool(Object.assign({ connectionLimit: 1 }, this.connectArgs()));
+        this.pool.on("error", this.onPoolError);
+    }
+    /** @param {Error} error */
+    onPoolError = (error) => {
+        console.error("Velocious / MySQL driver / Pool error", error);
+    };
+    /**
+     * @returns {Promise<void>}
+     */
+    async close() {
+        await this.pool?.end();
+        this.pool = undefined;
+    }
+    /**
+     * @returns {Record<string, any>}
+     */
+    connectArgs() {
+        const args = this.getArgs();
+        const forward = ["database", "host", "password"];
+        /** @type {Record<string, any>} */
+        const connectArgs = {};
+        for (const forwardValue of forward) {
+            if (forwardValue in args)
+                connectArgs[forwardValue] = digg(args, forwardValue);
+        }
+        if ("username" in args)
+            connectArgs["user"] = args["username"];
+        return connectArgs;
+    }
+    /**
+     * @param {import("../../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async alterTableSQLs(tableData) {
+        const alterArgs = { tableData, driver: this };
+        const alterTable = new AlterTable(alterArgs);
+        return await alterTable.toSQLs();
+    }
+    /**
+     * @param {string} databaseName
+     * @param {object} [args]
+     * @param {boolean} [args.ifNotExists]
+     * @returns {string[]}
+     */
+    createDatabaseSql(databaseName, args) {
+        const createArgs = Object.assign({ databaseName, driver: this }, args);
+        const createDatabase = new CreateDatabase(createArgs);
+        return createDatabase.toSql();
+    }
+    /**
+     * @param {import("../base.js").CreateIndexSqlArgs} indexData
+     * @returns {Promise<string[]>}
+     */
+    async createIndexSQLs(indexData) {
+        const createArgs = Object.assign({ driver: this }, indexData);
+        const createIndex = new CreateIndex(createArgs);
+        return await createIndex.toSQLs();
+    }
+    /**
+     * @param {import("../../table-data/index.js").default} tableData
+     * @returns {Promise<string[]>}
+     */
+    async createTableSql(tableData) {
+        const createArgs = { tableData, driver: this };
+        const createTable = new CreateTable(createArgs);
+        return createTable.toSql();
+    }
+    /**
+     * @returns {Promise<string>}
+     */
+    async currentDatabase() {
+        const rows = await this.query("SELECT DATABASE() AS db_name");
+        return digg(rows, 0, "db_name");
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async disableForeignKeys() {
+        await this.query("SET FOREIGN_KEY_CHECKS = 0");
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async enableForeignKeys() {
+        await this.query("SET FOREIGN_KEY_CHECKS = 1");
+    }
+    /**
+     * @param {string} tableName
+     * @param {import("../base.js").DropTableSqlArgsType} [args]
+     * @returns {Promise<string[]>}
+     */
+    async dropTableSQLs(tableName, args = {}) {
+        const dropArgs = Object.assign({ tableName, driver: this }, args);
+        const dropTable = new DropTable(dropArgs);
+        return await dropTable.toSQLs();
+    }
+    /**
+     * @returns {string}
+     */
+    getType() { return "mysql"; }
+    /**
+     * @returns {string}
+     */
+    primaryKeyType() { return "bigint"; }
+    /**
+     * @param {string} sql
+     * @returns {Promise<import("../base.js").QueryResultType>}
+     */
+    async _queryActual(sql) {
+        if (!this.pool)
+            throw new Error("Not connected to a pool yet");
+        try {
+            return await query(this.pool, sql);
+        }
+        catch (error) {
+            // Re-throw to un-corrupt stacktrace
+            if (error instanceof Error) {
+                throw new Error(`Query failed: ${error.message}`);
+            }
+            else {
+                throw new Error(`Query failed: ${error}`);
+            }
+        }
+    }
+    /**
+     * @param {import("../../query/index.js").default} query
+     * @returns {string}
+     */
+    queryToSql(query) { return new QueryParser({ query }).toSql(); }
+    /**
+     * @returns {boolean}
+     */
+    shouldSetAutoIncrementWhenPrimaryKey() { return true; }
+    /**
+     * @param {any} value
+     * @returns {any}
+     */
+    escape(value) {
+        if (!this.pool)
+            throw new Error("Can't escape before connected");
+        const escapedValueWithQuotes = this.pool.escape(this._convertValue(value));
+        return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1);
+    }
+    /**
+     * @param {string} value
+     * @returns {string}
+     */
+    quote(value) {
+        if (!this.pool)
+            throw new Error("Can't escape before connected");
+        return this.pool.escape(this._convertValue(value));
+    }
+    /**
+     * @param {import("../base.js").DeleteSqlArgsType} args
+     * @returns {string}
+     */
+    deleteSql({ tableName, conditions }) {
+        const deleteInstruction = new Delete({ conditions, driver: this, tableName });
+        return deleteInstruction.toSql();
+    }
+    /**
+     * @abstract
+     * @param {import("../base.js").InsertSqlArgsType} args
+     * @returns {string}
+     */
+    insertSql(args) {
+        const insertArgs = Object.assign({ driver: this }, args);
+        const insert = new Insert(insertArgs);
+        return insert.toSql();
+    }
+    /**
+     * @returns {Promise<Array<import("../base-table.js").default>>}
+     */
+    async getTables() {
+        const result = await this.query("SHOW FULL TABLES");
+        const tables = [];
+        for (const row of result) {
+            const table = new Table(this, row);
+            tables.push(table);
+        }
+        return tables;
+    }
+    /**
+     * @returns {Promise<number>}
+     */
+    async lastInsertID() {
+        const result = await this.query("SELECT LAST_INSERT_ID() AS last_insert_id");
+        return digg(result, 0, "last_insert_id");
+    }
+    /**
+     * @returns {Options}
+     */
+    options() {
+        if (!this._options)
+            this._options = new Options({ driver: this });
+        return this._options;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async _startTransactionAction() {
+        await this.query("START TRANSACTION");
+    }
+    /**
+     * @param {import("../base.js").UpdateSqlArgsType} args
+     * @returns {string}
+     */
+    updateSql({ conditions, data, tableName }) {
+        const update = new Update({ conditions, data, driver: this, tableName });
+        return update.toSql();
+    }
+}

package/dist/src/database/drivers/mysql/options.d.ts

@@ -0,0 +1,11 @@
+export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
+    /**
+     * @param {object} args
+     * @param {import("../base.js").default} args.driver
+     */
+    constructor({ driver }: {
+        driver: import("../base.js").default;
+    });
+}
+import QueryParserOptions from "../../query-parser/options.js";
+//# sourceMappingURL=options.d.ts.map

package/dist/src/database/drivers/mysql/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/options.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,wBAFG;QAA2C,MAAM,EAAzC,OAAO,YAAY,EAAE,OAAO;KACtC,EAWA;CAWF;+BA5B8B,+BAA+B"}