velocious 1.0.108 → 1.0.109

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

@@ -0,0 +1,111 @@
+// @ts-check
+import Configuration from "../../configuration.js";
+import { digg } from "diggerize";
+import { Logger } from "../../logger.js";
+import baseMethodsForward from "./base-methods-forward.js";
+/** @type {{currentPool: VelociousDatabasePoolBase | null}} */
+const shared = {
+    currentPool: null
+};
+class VelociousDatabasePoolBase {
+    /**
+     * @returns {VelociousDatabasePoolBase}
+     */
+    static current() {
+        if (!shared.currentPool)
+            throw new Error("A database pool hasn't been set");
+        return shared.currentPool;
+    }
+    /**
+     * @param {object} args
+     * @param {Configuration} args.configuration
+     * @param {string} args.identifier
+     */
+    constructor({ configuration, identifier }) {
+        this.configuration = configuration || Configuration.current();
+        if (!this.configuration)
+            throw new Error("No configuration given");
+        if (!identifier)
+            throw new Error("No identifier was given");
+        this.identifier = identifier;
+        this.logger = new Logger(this);
+    }
+    /**
+     * @abstract
+     * @param {import("../drivers/base.js").default} _connection
+     */
+    checkin(_connection) {
+        throw new Error("'checkin' not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    checkout() {
+        throw new Error("'checkout' not implemented");
+    }
+    /**
+     * @abstract
+     * @returns {import("../drivers/base.js").default}
+     */
+    getCurrentConnection() {
+        throw new Error("'getCurrentConnection' not implemented");
+    }
+    /**
+     * @returns {{driver: typeof import("../drivers/base.js").default, type: string}}
+     */
+    getConfiguration() {
+        return digg(this.configuration.getDatabaseConfiguration(), this.identifier);
+    }
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    primaryKeyType() {
+        throw new Error("'primaryKeyType' not implemented");
+    }
+    /**
+     * @returns {void}
+     */
+    setCurrent() {
+        shared.currentPool = this;
+    }
+    /**
+     * @param {typeof import("../drivers/base.js").default} driverClass
+     */
+    setDriverClass(driverClass) {
+        this.driverClass = driverClass;
+    }
+    /**
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    async spawnConnection() {
+        const databaseConfig = this.getConfiguration();
+        this.logger.debug("spawnConnection", { identifier: this.identifier, databaseConfig });
+        const connection = await this.spawnConnectionWithConfiguration(databaseConfig);
+        return connection;
+    }
+    /**
+     * @param {object} config
+     * @param {typeof import("../drivers/base.js").default} config.driver
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    async spawnConnectionWithConfiguration(config) {
+        const DriverClass = config.driver || this.driverClass;
+        if (!DriverClass)
+            throw new Error("No driver class set in database pool or in given config");
+        const connection = new DriverClass(config, this.configuration);
+        await connection.connect();
+        return connection;
+    }
+    /**
+     * @abstract
+     * @param {function(import("../drivers/base.js").default) : void} _callback
+     * @returns {Promise<void>}
+     */
+    withConnection(_callback) {
+        throw new Error("'withConnection' not implemented");
+    }
+}
+baseMethodsForward(VelociousDatabasePoolBase);
+export default VelociousDatabasePoolBase;

package/dist/src/database/pool/single-multi-use.d.ts

@@ -0,0 +1,5 @@
+export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
+    connection: import("../drivers/base.js").default;
+}
+import BasePool from "./base.js";
+//# sourceMappingURL=single-multi-use.d.ts.map

package/dist/src/database/pool/single-multi-use.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-multi-use.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/single-multi-use.js"],"names":[],"mappings":"AAIA;IAaM,iDAA8C;CAyBnD;qBAxCoB,WAAW"}

package/dist/src/database/pool/single-multi-use.js

@@ -0,0 +1,35 @@
+// @ts-check
+import BasePool from "./base.js";
+export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
+    /**
+     * @param {import("../drivers/base.js").default} _connection
+     */
+    checkin(_connection) {
+        // Do nothing
+    }
+    /**
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    async checkout() {
+        if (!this.connection) {
+            this.connection = await this.spawnConnection();
+        }
+        return this.connection;
+    }
+    /**
+     * @param {function(import("../drivers/base.js").default) : void} callback
+     */
+    async withConnection(callback) {
+        const connection = await this.checkout();
+        await callback(connection);
+    }
+    /**
+     * @returns {import("../drivers/base.js").default}
+     */
+    getCurrentConnection() {
+        if (!this.connection) {
+            throw new Error("A connection hasn't been made yet");
+        }
+        return this.connection;
+    }
+}

package/dist/src/database/query/alter-table-base.d.ts

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {TableData} args.tableData
+     */
+    constructor({ driver, tableData, ...restArgs }: {
+        driver: import("../drivers/base.js").default;
+        tableData: TableData;
+    });
+    tableData: TableData;
+}
+import QueryBase from "./base.js";
+import TableData from "../table-data/index.js";
+//# sourceMappingURL=alter-table-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alter-table-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/alter-table-base.js"],"names":[],"mappings":"AAMA;IACE;;;;OAIG;IACH,gDAHG;QAAmD,MAAM,EAAjD,OAAO,oBAAoB,EAAE,OAAO;QACpB,SAAS,EAAzB,SAAS;KACnB,EAQA;IADC,qBAA0B;CA2C7B;sBA3DqB,WAAW;sBAEX,wBAAwB"}

package/dist/src/database/query/alter-table-base.js

@@ -0,0 +1,55 @@
+// @ts-check
+import QueryBase from "./base.js";
+import restArgsError from "../../utils/rest-args-error.js";
+import TableData from "../table-data/index.js";
+export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {TableData} args.tableData
+     */
+    constructor({ driver, tableData, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!(tableData instanceof TableData))
+            throw new Error("Invalid table data was given");
+        super({ driver });
+        this.tableData = tableData;
+    }
+    /**
+     * @returns {Promise<string[]>}
+     */
+    async toSQLs() {
+        const databaseType = this.getDriver().getType();
+        const sqls = [];
+        const { tableData } = this;
+        const options = this.getOptions();
+        let sql = `ALTER TABLE ${options.quoteTableName(tableData.getName())} `;
+        let columnsCount = 0;
+        for (const column of tableData.getColumns()) {
+            if (columnsCount > 0)
+                sql += ", ";
+            if (column.isNewColumn()) {
+                sql += "ADD ";
+                sql += column.getSQL({ driver: this.getDriver(), forAlterTable: true });
+            }
+            else if (column.getNewName()) {
+                sql += `RENAME COLUMN ${options.quoteColumnName(column.getName())} TO ${options.quoteColumnName(column.getNewName())}`;
+            }
+            else if (column.getDropColumn()) {
+                sql += `DROP COLUMN ${options.quoteColumnName}`;
+            }
+            else {
+                if (databaseType == "mssql" || databaseType == "pgsql") {
+                    sql += "ALTER COLUMN ";
+                }
+                else {
+                    sql += "MODIFY ";
+                }
+                sql += column.getSQL({ driver: this.getDriver(), forAlterTable: true });
+            }
+            columnsCount++;
+        }
+        sqls.push(sql);
+        return sqls;
+    }
+}

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

@@ -0,0 +1,26 @@
+export default class VelociousDatabaseQueryBase {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {import("../query-parser/options.js").default} [args.options]
+     */
+    constructor({ driver, options, ...restArgs }: {
+        driver: import("../drivers/base.js").default;
+        options?: import("../query-parser/options.js").default;
+    });
+    _driver: import("../drivers/base.js").default;
+    _options: import("../query-parser/options.js").default;
+    getConfiguration(): import("../../configuration.js").default;
+    getDriver(): import("../drivers/base.js").default;
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions(): import("../query-parser/options.js").default;
+    getDatabaseType(): string;
+    /**
+     * @abstract
+     * @returns {Promise<string[]>}
+     */
+    toSQLs(): Promise<string[]>;
+}
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/base.js"],"names":[],"mappings":"AAIA;IACE;;;;OAIG;IACH,8CAHG;QAAmD,MAAM,EAAjD,OAAO,oBAAoB,EAAE,OAAO;QACgB,OAAO,GAA3D,OAAO,4BAA4B,EAAE,OAAO;KAAgB,EAStE;IAJC,8CAAqB;IACrB,uDAA2C;IAK7C,6DAEC;IAED,kDAEC;IAED;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED,0BAEC;IAED;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAI7B;CACF"}

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

@@ -0,0 +1,38 @@
+// @ts-check
+import restArgsError from "../../utils/rest-args-error.js";
+export default class VelociousDatabaseQueryBase {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {import("../query-parser/options.js").default} [args.options]
+     */
+    constructor({ driver, options, ...restArgs }) {
+        restArgsError(restArgs);
+        this._driver = driver;
+        this._options = options || driver.options();
+        if (!this._options)
+            throw new Error("No database options was given or could be gotten from driver");
+    }
+    getConfiguration() {
+        return this.getDriver().getConfiguration();
+    }
+    getDriver() {
+        return this._driver;
+    }
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions() {
+        return this._options;
+    }
+    getDatabaseType() {
+        return this.getDriver().getType();
+    }
+    /**
+     * @abstract
+     * @returns {Promise<string[]>}
+     */
+    async toSQLs() {
+        throw new Error("'toSQLs' wasn't implemented");
+    }
+}

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

@@ -0,0 +1,19 @@
+export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
+    /**
+     * @param {CreateDatabaseArgsType} args
+     */
+    constructor({ driver, databaseName, ifNotExists }: CreateDatabaseArgsType);
+    databaseName: string;
+    ifNotExists: boolean;
+    /**
+     * @returns {string[]}
+     */
+    toSql(): string[];
+}
+export type CreateDatabaseArgsType = {
+    driver: import("../drivers/base.js").default;
+    databaseName: string;
+    ifNotExists?: boolean;
+};
+import QueryBase from "./base.js";
+//# sourceMappingURL=create-database-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-database-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/create-database-base.js"],"names":[],"mappings":"AAWA;IACE;;OAEG;IACH,mDAFW,sBAAsB,EAMhC;IAFC,qBAAgC;IAChC,qBAA8B;IAGhC;;OAEG;IACH,SAFa,MAAM,EAAE,CAWpB;CACF;;YA9Ba,OAAO,oBAAoB,EAAE,OAAO;kBACpC,MAAM;kBACN,OAAO;;sBAGC,WAAW"}

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

@@ -0,0 +1,29 @@
+// @ts-check
+/**
+ * @typedef {object} CreateDatabaseArgsType
+ * @property {import("../drivers/base.js").default} driver
+ * @property {string} databaseName
+ * @property {boolean} [ifNotExists]
+ */
+import QueryBase from "./base.js";
+export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
+    /**
+     * @param {CreateDatabaseArgsType} args
+     */
+    constructor({ driver, databaseName, ifNotExists }) {
+        super({ driver });
+        this.databaseName = databaseName;
+        this.ifNotExists = ifNotExists;
+    }
+    /**
+     * @returns {string[]}
+     */
+    toSql() {
+        const { databaseName } = this;
+        let sql = "CREATE DATABASE";
+        if (this.ifNotExists)
+            sql += " IF NOT EXISTS";
+        sql += ` ${this.getOptions().quoteDatabaseName(databaseName)}`;
+        return [sql];
+    }
+}

package/dist/src/database/query/create-index-base.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {object} CreateIndexBaseArgsType
+ * @property {Array<string | import("./../table-data/table-column.js").default>} columns
+ * @property {import("../drivers/base.js").default} driver
+ * @property {boolean} [ifNotExists]
+ * @property {string} [name]
+ * @property {boolean} [unique]
+ * @property {string} tableName
+ */
+export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
+    /**
+     * @param {CreateIndexBaseArgsType} args
+     */
+    constructor({ columns, driver, ifNotExists, name, unique, tableName }: CreateIndexBaseArgsType);
+    columns: (string | import("./../table-data/table-column.js").default)[];
+    name: string;
+    tableName: string;
+    ifNotExists: boolean;
+    unique: boolean;
+    generateIndexName(): string;
+}
+export type CreateIndexBaseArgsType = {
+    columns: Array<string | import("./../table-data/table-column.js").default>;
+    driver: import("../drivers/base.js").default;
+    ifNotExists?: boolean;
+    name?: string;
+    unique?: boolean;
+    tableName: string;
+};
+import QueryBase from "./base.js";
+//# sourceMappingURL=create-index-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-index-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/create-index-base.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH;IACE;;OAEG;IACH,uEAFW,uBAAuB,EASjC;IALC,wEAAsB;IACtB,aAAgB;IAChB,kBAA0B;IAC1B,qBAA8B;IAC9B,gBAAoB;IAGtB,4BAwBC;CA8DF;;aA3Ga,KAAK,CAAC,MAAM,GAAG,OAAO,iCAAiC,EAAE,OAAO,CAAC;YACjE,OAAO,oBAAoB,EAAE,OAAO;kBACpC,OAAO;WACP,MAAM;aACN,OAAO;eACP,MAAM;;sBATE,WAAW"}

package/dist/src/database/query/create-index-base.js

@@ -0,0 +1,94 @@
+// @ts-check
+import QueryBase from "./base.js";
+/**
+ * @typedef {object} CreateIndexBaseArgsType
+ * @property {Array<string | import("./../table-data/table-column.js").default>} columns
+ * @property {import("../drivers/base.js").default} driver
+ * @property {boolean} [ifNotExists]
+ * @property {string} [name]
+ * @property {boolean} [unique]
+ * @property {string} tableName
+ */
+export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
+    /**
+     * @param {CreateIndexBaseArgsType} args
+     */
+    constructor({ columns, driver, ifNotExists, name, unique, tableName }) {
+        super({ driver });
+        this.columns = columns;
+        this.name = name;
+        this.tableName = tableName;
+        this.ifNotExists = ifNotExists;
+        this.unique = unique;
+    }
+    generateIndexName() {
+        const databaseType = this.getDriver().getType();
+        let indexName = `index_on_`;
+        let columnCount = 0;
+        if (databaseType == "sqlite")
+            indexName += `${this.tableName}_`;
+        for (const column of this.columns) {
+            columnCount++;
+            if (columnCount > 1)
+                indexName += "_and_";
+            let columnName;
+            if (typeof column == "string") {
+                columnName = column;
+            }
+            else {
+                columnName = column.getName();
+            }
+            indexName += columnName;
+        }
+        return indexName;
+    }
+    /**
+     * @returns {Promise<string[]>}
+     */
+    async toSQLs() {
+        const databaseType = this.getDriver().getType();
+        const indexName = this.name || this.generateIndexName();
+        const options = this.getOptions();
+        const { tableName } = this;
+        let sql = "";
+        if (this.ifNotExists && databaseType == "mssql") {
+            sql += `
+        IF NOT EXISTS (
+          SELECT 1
+          FROM sys.indexes
+          WHERE
+            name = ${options.quote(indexName)} AND
+            object_id = OBJECT_ID(${options.quote(`dbo.${tableName}`)})
+        )
+        BEGIN
+      `;
+        }
+        sql += "CREATE";
+        if (this.unique)
+            sql += " UNIQUE";
+        sql += " INDEX";
+        if (this.ifNotExists && databaseType != "mssql")
+            sql += " IF NOT EXISTS";
+        sql += ` ${options.quoteIndexName(indexName)}`;
+        sql += ` ON ${options.quoteTableName(tableName)} (`;
+        let columnCount = 0;
+        for (const column of this.columns) {
+            columnCount++;
+            if (columnCount > 1)
+                sql += ", ";
+            let columnName;
+            if (typeof column == "string") {
+                columnName = column;
+            }
+            else {
+                columnName = column.getName();
+            }
+            sql += `${options.quoteColumnName(columnName)}`;
+        }
+        sql += ")";
+        if (this.ifNotExists && databaseType == "mssql") {
+            sql += " END";
+        }
+        return [sql];
+    }
+}

package/dist/src/database/query/create-table-base.d.ts

@@ -0,0 +1,25 @@
+export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {boolean} [args.ifNotExists]
+     * @param {boolean} [args.indexInCreateTable]
+     * @param {TableData} args.tableData
+     */
+    constructor({ driver, ifNotExists, indexInCreateTable, tableData }: {
+        driver: import("../drivers/base.js").default;
+        ifNotExists?: boolean;
+        indexInCreateTable?: boolean;
+        tableData: TableData;
+    });
+    ifNotExists: boolean;
+    indexInCreateTable: boolean;
+    tableData: TableData;
+    /**
+     * @returns {Promise<string[]>}
+     */
+    toSql(): Promise<string[]>;
+}
+import QueryBase from "./base.js";
+import TableData from "../table-data/index.js";
+//# sourceMappingURL=create-table-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-table-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/create-table-base.js"],"names":[],"mappings":"AAQA;IACE;;;;;;OAMG;IACH,oEALG;QAAmD,MAAM,EAAjD,OAAO,oBAAoB,EAAE,OAAO;QACrB,WAAW,GAA1B,OAAO;QACQ,kBAAkB,GAAjC,OAAO;QACS,SAAS,EAAzB,SAAS;KACnB,EAQA;IAHC,qBAA8B;IAC9B,4BAA4C;IAC5C,qBAA0B;IAG5B;;OAEG;IACH,SAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CA6I7B;CACF;sBArKqB,WAAW;sBAEX,wBAAwB"}

package/dist/src/database/query/create-table-base.js

@@ -0,0 +1,136 @@
+// @ts-check
+import CreateIndexBase from "./create-index-base.js";
+import QueryBase from "./base.js";
+import restArgsError from "../../utils/rest-args-error.js";
+import TableData from "../table-data/index.js";
+import TableColumn from "../table-data/table-column.js";
+export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
+    /**
+     * @param {object} args
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {boolean} [args.ifNotExists]
+     * @param {boolean} [args.indexInCreateTable]
+     * @param {TableData} args.tableData
+     */
+    constructor({ driver, ifNotExists, indexInCreateTable = true, tableData }) {
+        if (!(tableData instanceof TableData))
+            throw new Error("Invalid table data was given");
+        super({ driver });
+        this.ifNotExists = ifNotExists;
+        this.indexInCreateTable = indexInCreateTable;
+        this.tableData = tableData;
+    }
+    /**
+     * @returns {Promise<string[]>}
+     */
+    async toSql() {
+        const databaseType = this.getDatabaseType();
+        const driver = this.getDriver();
+        const options = this.getOptions();
+        const { tableData } = this;
+        const sqls = [];
+        const ifNotExists = this.ifNotExists || tableData.getIfNotExists();
+        let sql = "";
+        if (databaseType == "mssql" && ifNotExists) {
+            sql += `IF NOT EXISTS(SELECT * FROM [sysobjects] WHERE [name] = ${options.quote(tableData.getName())} AND [xtype] = 'U') BEGIN `;
+        }
+        sql += "CREATE TABLE";
+        if (databaseType != "mssql" && ifNotExists)
+            sql += " IF NOT EXISTS";
+        sql += ` ${options.quoteTableName(tableData.getName())} (`;
+        let columnCount = 0;
+        for (const column of tableData.getColumns()) {
+            columnCount++;
+            if (columnCount > 1)
+                sql += ", ";
+            sql += column.getSQL({ driver, forAlterTable: false });
+        }
+        if (this.indexInCreateTable) {
+            for (const index of tableData.getIndexes()) {
+                sql += ",";
+                if (index.getUnique()) {
+                    sql += " UNIQUE";
+                }
+                sql += " INDEX";
+                if (index.getName()) {
+                    sql += ` ${options.quoteIndexName(index.getName())}`;
+                }
+                sql += " (";
+                index.getColumns().forEach((column, columnIndex) => {
+                    if (columnIndex > 0)
+                        sql += ", ";
+                    if (column instanceof TableColumn) {
+                        sql += driver.quoteColumn(column.getName());
+                    }
+                    else if (typeof column == "string") {
+                        sql += driver.quoteColumn(column);
+                    }
+                    else {
+                        throw new Error(`Unknown column type: ${typeof column}`);
+                    }
+                });
+                sql += ")";
+            }
+            // Create indexes for all columns with the index argument
+            for (const column of tableData.getColumns()) {
+                if (!column.getIndex())
+                    continue;
+                let indexName = `index_on_`;
+                if (databaseType == "sqlite")
+                    sql += `${tableData.getName()}_`;
+                indexName += column.getName();
+                sql += ",";
+                const { unique, ...restIndexArgs } = column.getIndexArgs();
+                restArgsError(restIndexArgs);
+                if (unique) {
+                    sql += " UNIQUE";
+                }
+                sql += ` INDEX ${options.quoteIndexName(indexName)} (${options.quoteColumnName(column.getName())})`;
+            }
+        }
+        sql += ")";
+        if (databaseType == "mssql" && ifNotExists) {
+            sql += " END";
+        }
+        sqls.push(sql);
+        if (!this.indexInCreateTable) {
+            for (const index of tableData.getIndexes()) {
+                const createIndexArgs = {
+                    columns: index.getColumns(),
+                    driver: this.getDriver(),
+                    ifNotExists: true,
+                    name: index.getName(),
+                    tableName: tableData.getName(),
+                    unique: index.getUnique()
+                };
+                const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs();
+                for (const createIndexSQL of createIndexSQLs) {
+                    sqls.push(createIndexSQL);
+                }
+            }
+            // Create indexes for all columns with the index argument
+            for (const column of tableData.getColumns()) {
+                if (!column.getIndex())
+                    continue;
+                const { unique, ...restIndexArgs } = column.getIndexArgs();
+                restArgsError(restIndexArgs);
+                let indexName = `index_on_`;
+                if (databaseType == "sqlite")
+                    indexName += `${tableData.getName()}_`;
+                indexName += column.getName();
+                const createIndexArgs = {
+                    columns: [column.getName()],
+                    driver: this.getDriver(),
+                    name: indexName,
+                    tableName: tableData.getName(),
+                    unique
+                };
+                const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs();
+                for (const createIndexSQL of createIndexSQLs) {
+                    sqls.push(createIndexSQL);
+                }
+            }
+        }
+        return sqls;
+    }
+}

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

@@ -0,0 +1,17 @@
+export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
+    /**
+     * @param {object} args
+     * @param {Record<string, any>} args.conditions
+     * @param {import("../drivers/base.js").default} args.driver
+     * @param {string} args.tableName
+     */
+    constructor({ conditions, driver, tableName }: {
+        conditions: Record<string, any>;
+        driver: import("../drivers/base.js").default;
+        tableName: string;
+    });
+    conditions: Record<string, any>;
+    tableName: string;
+}
+import QueryBase from "./base.js";
+//# sourceMappingURL=delete-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-base.d.ts","sourceRoot":"","sources":["../../../../src/database/query/delete-base.js"],"names":[],"mappings":"AAIA;IACE;;;;;OAKG;IACH,+CAJG;QAAkC,UAAU,EAApC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACwB,MAAM,EAAjD,OAAO,oBAAoB,EAAE,OAAO;QACvB,SAAS,EAAtB,MAAM;KAChB,EAKA;IAFC,gCAA4B;IAC5B,kBAA0B;CAE7B;sBAdqB,WAAW"}