velocious 1.0.108 → 1.0.109

package/dist/src/database/migrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrator.d.ts","sourceRoot":"","sources":["../../../src/database/migrator.js"],"names":[],"mappings":"AASA;IAIE;;;OAGG;IACH,4CAFG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC/C,EAQA;IAdD,sDAAsD;IACtD,oBADW,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAC3B;IAWrB,qDAAkC;IAClC,eAA8C;IAGhD;;OAEG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;OAEG;IACH,yBAFa,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAED,8BAEC;IAED;;;;OAIG;IACH,qCAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAWnB;IAED;;;OAGG;IACH,oBAHW,OAAO,qBAAqB,EAAE,mBAAmB,EAAE,kBACnD,OAAO,qBAAqB,EAAE,0BAA0B,iBAqBlE;IAED;;;OAGG;IACH,+CAHW,OAAO,qBAAqB,EAAE,2BAA2B,GACvD,OAAO,CAAC,IAAI,CAAC,CA2CzB;IAED;;OAEG;IACH,0BAFa,OAAO,CAAC,IAAI,CAAC,CA+BzB;IAED;;;OAGG;IACH,yBAHW,OAAO,mBAAmB,EAAE,OAAO,GACjC,OAAO,CAAC,OAAO,CAAC,CAQ5B;IAED;;;OAGG;IACH,sCAHW,OAAO,qBAAqB,EAAE,2BAA2B,GACvD,OAAO,CAAC,IAAI,CAAC,CAkCzB;IAED;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAoCzB;IAED;;;;OAIG;IACH,gBAJW,OAAO,qBAAqB,EAAE,mBAAmB,EAAE,kBACnD,OAAO,qBAAqB,EAAE,0BAA0B,GACtD,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;OAEG;IACH,2BAFa,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiBvC;IAED;;;;;OAKG;IACH,6DAJG;QAAgE,SAAS,EAAjE,OAAO,qBAAqB,EAAE,mBAAmB;QACQ,gBAAgB,EAAzE,OAAO,qBAAqB,EAAE,oBAAoB;QACpC,SAAS,GAAvB,MAAM;KAAkB,iBAiGlC;CACF;uBA7aoB,cAAc"}

package/dist/src/database/migrator.js

@@ -0,0 +1,377 @@
+// @ts-check
+import { digg } from "diggerize";
+import * as inflection from "inflection";
+import { Logger } from "../logger.js";
+import { NotImplementedError } from "./migration/index.js";
+import restArgsError from "../utils/rest-args-error.js";
+import TableData from "./table-data/index.js";
+export default class VelociousDatabaseMigrator {
+    /** @type {Record<string, Record<string, boolean>>} */
+    migrationsVersions = {};
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     */
+    constructor({ configuration, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!configuration)
+            throw new Error("configuration argument is required");
+        this.configuration = configuration;
+        this.logger = new Logger(this, { debug: false });
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async prepare() {
+        await this.createMigrationsTable();
+        await this.loadMigrationsVersions();
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async createMigrationsTable() {
+        const dbs = await this.configuration.getCurrentConnections();
+        for (const dbIdentifier in dbs) {
+            const db = dbs[dbIdentifier];
+            const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
+            if (!databaseConfiguration.migrations) {
+                this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping creating migrations table for it`);
+                continue;
+            }
+            if (await this.migrationsTableExist(db)) {
+                this.logger.debug(`${dbIdentifier} migrations table already exists - skipping`);
+                continue;
+            }
+            const schemaMigrationsTable = new TableData("schema_migrations", { ifNotExists: true });
+            schemaMigrationsTable.string("version", { null: false, primaryKey: true });
+            const createSchemaMigrationsTableSqls = await db.createTableSql(schemaMigrationsTable);
+            for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
+                await db.query(createSchemaMigrationsTableSql);
+            }
+        }
+    }
+    async dropDatabase() {
+        throw new Error("Not implemented yet");
+    }
+    /**
+     * @param {string} dbIdentifier
+     * @param {number} version
+     * @returns {boolean}
+     */
+    hasRunMigrationVersion(dbIdentifier, version) {
+        if (!this.migrationsVersions)
+            throw new Error("Migrations versions hasn't been loaded yet");
+        if (!this.migrationsVersions[dbIdentifier])
+            throw new Error(`Migrations versions hasn't been loaded yet for db: ${dbIdentifier}`);
+        if (version in this.migrationsVersions[dbIdentifier]) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * @param {import("./migrator/types.js").MigrationObjectType[]} files
+     * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback
+     */
+    async migrateFiles(files, importCallback) {
+        await this.configuration.ensureConnections(async () => {
+            for (const migration of files) {
+                await this.runMigrationFile({
+                    migration,
+                    requireMigration: async () => {
+                        if (!migration.fullPath)
+                            throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(", ")}`);
+                        const migrationImport = await importCallback(migration.fullPath);
+                        if (!migrationImport) {
+                            throw new Error(`Migration file must export migration class: ${migration.fullPath}`);
+                        }
+                        return migrationImport;
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext
+     * @returns {Promise<void>}
+     */
+    async migrateFilesFromRequireContext(requireContext) {
+        /** @type {import("./migrator/types.js").MigrationObjectType[]} */
+        let files = [];
+        for (const file of requireContext.keys()) {
+            // "13,14" because somes "require-context"-npm-module deletes first character!?
+            const match = file.match(/(\d{13,14})-(.+)\.js$/);
+            if (!match)
+                continue;
+            // Fix require-context-npm-module deletes first character
+            let fileName = file;
+            let dateNumber = match[1];
+            if (dateNumber.length == 13) {
+                dateNumber = `2${dateNumber}`;
+                fileName = `2${fileName}`;
+            }
+            // Parse regex
+            const date = parseInt(dateNumber);
+            const migrationName = match[2];
+            const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"));
+            files.push({
+                file: fileName,
+                date,
+                migrationClassName
+            });
+        }
+        files = files.sort((migration1, migration2) => migration1.date - migration2.date);
+        await this.configuration.ensureConnections(async () => {
+            for (const migration of files) {
+                await this.runMigrationFile({
+                    migration,
+                    requireMigration: async () => requireContext(migration.file).default
+                });
+            }
+        });
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async loadMigrationsVersions() {
+        this.migrationsVersions = {};
+        const dbs = await this.configuration.getCurrentConnections();
+        for (const dbIdentifier in dbs) {
+            const db = dbs[dbIdentifier];
+            const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
+            if (!databaseConfiguration.migrations) {
+                this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping loading migrations versions for it`);
+                continue;
+            }
+            if (!await this.migrationsTableExist(db)) {
+                this.logger.log(`Migration table does not exist for ${dbIdentifier} - skipping loading migrations versions for it`);
+                continue;
+            }
+            const rows = await db.select("schema_migrations");
+            this.migrationsVersions[dbIdentifier] = {};
+            for (const row of rows) {
+                const version = digg(row, "version");
+                this.migrationsVersions[dbIdentifier][version] = true;
+            }
+        }
+    }
+    /**
+     * @param {import("./drivers/base.js").default} db
+     * @returns {Promise<boolean>}
+     */
+    async migrationsTableExist(db) {
+        const schemaTable = await db.getTableByName("schema_migrations", { throwError: false });
+        if (!schemaTable)
+            return false;
+        return true;
+    }
+    /**
+     * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext
+     * @returns {Promise<void>}
+     */
+    async executeRequireContext(requireContext) {
+        const migrationFiles = requireContext.keys();
+        /** @type {import("./migrator/types.js").MigrationObjectType[]} */
+        let files = [];
+        for (const file of migrationFiles) {
+            const match = file.match(/^(\d{14})-(.+)\.js$/);
+            if (!match)
+                continue;
+            const date = parseInt(match[1]);
+            const migrationName = match[2];
+            const migrationClassName = inflection.camelize(migrationName);
+            const migrationObject = /** @type {import("./migrator/types.js").MigrationObjectType} */ ({
+                file,
+                date,
+                migrationClassName
+            });
+            files.push(migrationObject);
+        }
+        files = files.sort((migration1, migration2) => migration1.date - migration2.date);
+        for (const migration of files) {
+            await this.runMigrationFile({
+                migration,
+                requireMigration: async () => requireContext(migration.file).default
+            });
+        }
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async reset() {
+        const dbs = await this.configuration.getCurrentConnections();
+        for (const dbIdentifier in dbs) {
+            const db = dbs[dbIdentifier];
+            await db.withDisabledForeignKeys(async () => {
+                while (true) {
+                    const errors = [];
+                    let anyTableDropped = false;
+                    try {
+                        for (const table of await db.getTables()) {
+                            this.logger.log(`Dropping table ${table.getName()}`);
+                            try {
+                                await db.dropTable(table.getName(), { cascade: true });
+                                anyTableDropped = true;
+                            }
+                            catch (error) {
+                                errors.push(error);
+                            }
+                        }
+                        break;
+                    }
+                    catch (error) { // eslint-disable-line no-unused-vars
+                        if (errors.length > 0 && anyTableDropped) {
+                            // Retry
+                        }
+                        else {
+                            throw errors[0];
+                        }
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * @param {import("./migrator/types.js").MigrationObjectType[]} files
+     * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback Function to import a file
+     * @returns {Promise<void>}
+     */
+    async rollback(files, importCallback) {
+        const latestMigrationVersion = await this._latestMigrationVersion();
+        if (!latestMigrationVersion) {
+            throw new Error("No migrations have been run yet");
+        }
+        const latestMigrationVersionNumber = parseInt(latestMigrationVersion);
+        const migration = files.find((file) => file.date == latestMigrationVersionNumber);
+        if (!migration) {
+            throw new Error(`Migration file for version ${latestMigrationVersionNumber} not found`);
+        }
+        await this.runMigrationFile({
+            migration,
+            requireMigration: async () => {
+                if (!migration.fullPath)
+                    throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(", ")}`);
+                return await importCallback(migration.fullPath);
+            },
+            direction: "down"
+        });
+    }
+    /**
+     * @returns {Promise<string | undefined>} The latest migration version
+     */
+    async _latestMigrationVersion() {
+        if (!this.migrationsVersions)
+            await this.loadMigrationsVersions();
+        /** @type {string | undefined} */
+        let highestVersion;
+        for (const dbIdentifier in this.migrationsVersions) {
+            for (const migrationVersion in this.migrationsVersions[dbIdentifier]) {
+                if (!highestVersion || migrationVersion > highestVersion) {
+                    highestVersion = migrationVersion;
+                }
+            }
+        }
+        return highestVersion;
+    }
+    /**
+     * @param {object} args
+     * @param {import("./migrator/types.js").MigrationObjectType} args.migration
+     * @param {import("./migrator/types.js").RequireMigrationType} args.requireMigration
+     * @param {string} [args.direction]
+     */
+    async runMigrationFile({ migration, requireMigration, direction = "up" }) {
+        if (!this.configuration)
+            throw new Error("No configuration set");
+        if (!this.configuration.isDatabasePoolInitialized())
+            await this.configuration.initializeDatabasePool();
+        if (!this.migrationsVersions)
+            await this.loadMigrationsVersions();
+        const dbs = await this.configuration.getCurrentConnections();
+        const migrationClass = await requireMigration();
+        if (!migrationClass || typeof migrationClass !== "function") {
+            throw new Error(`Migration ${migration.file} must export a default migration class. Type: ${typeof migrationClass}`);
+        }
+        const migrationDatabaseIdentifiers = migrationClass.getDatabaseIdentifiers() || ["default"];
+        for (const dbIdentifier in dbs) {
+            const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
+            if (!databaseConfiguration.migrations) {
+                this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping migration ${digg(migration, "date")}`);
+                continue;
+            }
+            if (!migrationDatabaseIdentifiers.includes(dbIdentifier)) {
+                this.logger.debug(`${dbIdentifier} shouldn't run migration ${migration.file}`, { migrationDatabaseIdentifiers });
+                continue;
+            }
+            if (direction == "up") {
+                if (this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
+                    this.logger.debug(`${dbIdentifier} has already run migration ${migration.file}`);
+                    continue;
+                }
+            }
+            else if (direction == "down") {
+                if (!this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
+                    this.logger.debug(`${dbIdentifier} hasn't run migration ${migration.file}`);
+                    continue;
+                }
+            }
+            else {
+                throw new Error(`Unknown direction: ${direction}`);
+            }
+            this.logger.debug(`Running migration on ${dbIdentifier}: ${migration.file}`, { migrationDatabaseIdentifiers });
+            const db = dbs[dbIdentifier];
+            const MigrationClass = migrationClass;
+            const migrationInstance = new MigrationClass({
+                configuration: this.configuration,
+                databaseIdentifier: dbIdentifier,
+                db
+            });
+            const dateString = `${digg(migration, "date")}`;
+            if (direction == "up") {
+                try {
+                    await migrationInstance.change();
+                }
+                catch (changeError) {
+                    if (changeError instanceof NotImplementedError) {
+                        try {
+                            await migrationInstance.up();
+                        }
+                        catch (upError) {
+                            if (upError instanceof NotImplementedError) {
+                                throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`);
+                            }
+                            else {
+                                throw upError;
+                            }
+                        }
+                    }
+                    else {
+                        throw changeError;
+                    }
+                }
+                const existingSchemaMigrations = await db.newQuery()
+                    .from("schema_migrations")
+                    .where({ version: dateString })
+                    .results();
+                if (existingSchemaMigrations.length == 0) {
+                    await db.insert({ tableName: "schema_migrations", data: { version: dateString } });
+                }
+            }
+            else if (direction == "down") {
+                try {
+                    await migrationInstance.down();
+                }
+                catch (downError) {
+                    if (downError instanceof NotImplementedError) {
+                        throw new Error(`'down' didn't exist on migration: ${migration.file} or migrating down with a change method isn't currently supported`);
+                    }
+                    else {
+                        throw downError;
+                    }
+                }
+                await db.delete({ tableName: "schema_migrations", conditions: { version: dateString } });
+            }
+            else {
+                throw new Error(`Unknown direction: ${direction}`);
+            }
+        }
+    }
+}

package/dist/src/database/pool/async-tracked-multi-connection.d.ts

@@ -0,0 +1,11 @@
+export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {
+    asyncLocalStorage: AsyncLocalStorage<any>;
+    /** @type {import("../drivers/base.js").default[]} */
+    connections: import("../drivers/base.js").default[];
+    /** @type {Record<number, import("../drivers/base.js").default>} */
+    connectionsInUse: Record<number, import("../drivers/base.js").default>;
+    idSeq: number;
+}
+import BasePool from "./base.js";
+import { AsyncLocalStorage } from "async_hooks";
+//# sourceMappingURL=async-tracked-multi-connection.d.ts.map

package/dist/src/database/pool/async-tracked-multi-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-tracked-multi-connection.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/async-tracked-multi-connection.js"],"names":[],"mappings":"AAKA;IACE,0CAA2C;IAE3C,qDAAqD;IACrD,aADW,OAAO,oBAAoB,EAAE,OAAO,EAAE,CACjC;IAEhB,mEAAmE;IACnE,kBADW,MAAM,CAAC,MAAM,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAC1C;IAErB,cAAS;CAwFV;qBAnGoB,WAAW;kCADA,aAAa"}

package/dist/src/database/pool/async-tracked-multi-connection.js

@@ -0,0 +1,80 @@
+// @ts-check
+import { AsyncLocalStorage } from "async_hooks";
+import BasePool from "./base.js";
+export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {
+    asyncLocalStorage = new AsyncLocalStorage();
+    /** @type {import("../drivers/base.js").default[]} */
+    connections = [];
+    /** @type {Record<number, import("../drivers/base.js").default>} */
+    connectionsInUse = {};
+    idSeq = 0;
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {string} args.identifier
+     */
+    constructor({ configuration, identifier }) {
+        super({ configuration, identifier });
+    }
+    /**
+     * @param {import("../drivers/base.js").default} connection
+     */
+    checkin(connection) {
+        const id = connection.getIdSeq();
+        if (typeof id !== "number") {
+            throw new Error(`idSeq on connection wasn't set? '${typeof id}' = ${id}`);
+        }
+        if (id in this.connectionsInUse) {
+            delete this.connectionsInUse[id];
+        }
+        connection.setIdSeq(undefined);
+        this.connections.push(connection);
+    }
+    /**
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    async checkout() {
+        let connection = this.connections.shift();
+        if (!connection) {
+            connection = await this.spawnConnection();
+        }
+        if (connection.getIdSeq() !== undefined)
+            throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`);
+        const id = this.idSeq++;
+        connection.setIdSeq(id);
+        this.connectionsInUse[id] = connection;
+        return connection;
+    }
+    /**
+     * @param {function(import("../drivers/base.js").default) : void} callback
+     */
+    async withConnection(callback) {
+        const connection = await this.checkout();
+        const id = connection.getIdSeq();
+        await this.asyncLocalStorage.run(id, async () => {
+            try {
+                await callback(connection);
+            }
+            finally {
+                this.checkin(connection);
+            }
+        });
+    }
+    /**
+     * @returns {import("../drivers/base.js").default}
+     */
+    getCurrentConnection() {
+        const id = this.asyncLocalStorage.getStore();
+        if (id === undefined) {
+            throw new Error("ID hasn't been set for this async context");
+        }
+        if (!(id in this.connectionsInUse)) {
+            throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`);
+        }
+        const currentConnection = this.connectionsInUse[id];
+        if (!currentConnection) {
+            throw new Error(`Couldn't get current connection from that ID: ${id}`);
+        }
+        return currentConnection;
+    }
+}

package/dist/src/database/pool/base-methods-forward.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {typeof import("./base.js").default} PoolBase
+ * @returns {void}
+ */
+export default function baseMethodsForward(PoolBase: typeof import("./base.js").default): void;
+//# sourceMappingURL=base-methods-forward.d.ts.map

package/dist/src/database/pool/base-methods-forward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-methods-forward.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/base-methods-forward.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAHW,cAAc,WAAW,EAAE,OAAO,GAChC,IAAI,CAmChB"}

package/dist/src/database/pool/base-methods-forward.js

@@ -0,0 +1,37 @@
+// @ts-check
+/**
+ * @param {typeof import("./base.js").default} PoolBase
+ * @returns {void}
+ */
+export default function baseMethodsForward(PoolBase) {
+    const forwardMethods = [
+        "alterTable",
+        "alterTableSQLs",
+        "createIndex",
+        "createIndexSQLs",
+        "createTable",
+        "createTableSql",
+        "delete",
+        "deleteSql",
+        "getTables",
+        "insert",
+        "insertSql",
+        "primaryKeyType",
+        "query",
+        "quote",
+        "quoteColumn",
+        "quoteTable",
+        "select",
+        "update",
+        "updateSql"
+    ];
+    for (const forwardMethod of forwardMethods) {
+        PoolBase.prototype[forwardMethod] = function (...args) {
+            const connection = this.getCurrentConnection();
+            const connectionMethod = connection[forwardMethod];
+            if (!connectionMethod)
+                throw new Error(`${forwardMethod} isn't defined on driver`);
+            return connection[forwardMethod](...args);
+        };
+    }
+}

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

@@ -0,0 +1,76 @@
+export default VelociousDatabasePoolBase;
+declare class VelociousDatabasePoolBase {
+    /**
+     * @returns {VelociousDatabasePoolBase}
+     */
+    static current(): VelociousDatabasePoolBase;
+    /**
+     * @param {object} args
+     * @param {Configuration} args.configuration
+     * @param {string} args.identifier
+     */
+    constructor({ configuration, identifier }: {
+        configuration: Configuration;
+        identifier: string;
+    });
+    configuration: Configuration;
+    identifier: string;
+    logger: Logger;
+    /**
+     * @abstract
+     * @param {import("../drivers/base.js").default} _connection
+     */
+    checkin(_connection: import("../drivers/base.js").default): void;
+    /**
+     * @abstract
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    checkout(): Promise<import("../drivers/base.js").default>;
+    /**
+     * @abstract
+     * @returns {import("../drivers/base.js").default}
+     */
+    getCurrentConnection(): import("../drivers/base.js").default;
+    /**
+     * @returns {{driver: typeof import("../drivers/base.js").default, type: string}}
+     */
+    getConfiguration(): {
+        driver: typeof import("../drivers/base.js").default;
+        type: string;
+    };
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    primaryKeyType(): string;
+    /**
+     * @returns {void}
+     */
+    setCurrent(): void;
+    /**
+     * @param {typeof import("../drivers/base.js").default} driverClass
+     */
+    setDriverClass(driverClass: typeof import("../drivers/base.js").default): void;
+    driverClass: typeof import("../drivers/base.js").default;
+    /**
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    spawnConnection(): Promise<import("../drivers/base.js").default>;
+    /**
+     * @param {object} config
+     * @param {typeof import("../drivers/base.js").default} config.driver
+     * @returns {Promise<import("../drivers/base.js").default>}
+     */
+    spawnConnectionWithConfiguration(config: {
+        driver: typeof import("../drivers/base.js").default;
+    }): Promise<import("../drivers/base.js").default>;
+    /**
+     * @abstract
+     * @param {function(import("../drivers/base.js").default) : void} _callback
+     * @returns {Promise<void>}
+     */
+    withConnection(_callback: (arg0: import("../drivers/base.js").default) => void): Promise<void>;
+}
+import Configuration from "../../configuration.js";
+import { Logger } from "../../logger.js";
+//# sourceMappingURL=base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/database/pool/base.js"],"names":[],"mappings":";AAYA;IACE;;OAEG;IACH,kBAFa,yBAAyB,CAMrC;IAED;;;;OAIG;IACH,2CAHG;QAA4B,aAAa,EAAjC,aAAa;QACA,UAAU,EAAvB,MAAM;KAChB,EASA;IAPC,6BAA6D;IAK7D,mBAA4B;IAC5B,eAA8B;IAGhC;;;OAGG;IACH,qBAFW,OAAO,oBAAoB,EAAE,OAAO,QAI9C;IAED;;;OAGG;IACH,YAFa,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAIzD;IAED;;;OAGG;IACH,wBAFa,OAAO,oBAAoB,EAAE,OAAO,CAIhD;IAED;;OAEG;IACH,oBAFa;QAAC,MAAM,EAAE,cAAc,oBAAoB,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAI/E;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAED;;OAEG;IACH,cAFa,IAAI,CAIhB;IAED;;OAEG;IACH,4BAFW,cAAc,oBAAoB,EAAE,OAAO,QAIrD;IADC,yDAA8B;IAGhC;;OAEG;IACH,mBAFa,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAUzD;IAED;;;;OAIG;IACH,yCAHG;QAA4D,MAAM,EAA1D,cAAc,oBAAoB,EAAE,OAAO;KACnD,GAAU,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAYzD;IAED;;;;OAIG;IACH,0BAHW,CAAS,IAAoC,EAApC,OAAO,oBAAoB,EAAE,OAAO,KAAI,IAAI,GACnD,OAAO,CAAC,IAAI,CAAC,CAIzB;CACF;0BA9HyB,wBAAwB;uBAE7B,iBAAiB"}