ueberdb2 5.0.43 → 5.0.44

package/dist/{lib/AbstractDatabase.js → AbstractDatabase-a4jdIEuT.js}

@@ -1,5 +1,5 @@
 //#region lib/AbstractDatabase.ts
-const nullLogger = require("./logging.js").normalizeLogger(null);
+const nullLogger = require("./logging-DmqnZRde.js").normalizeLogger(null);
 const simpleGlobToRegExp = (s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
 var AbstractDatabase = class {
 	logger;
@@ -33,4 +33,9 @@ var AbstractDatabase = class {
 	}
 };
 //#endregion
-exports.default = AbstractDatabase;
+Object.defineProperty(exports, "AbstractDatabase", {
+	enumerable: true,
+	get: function() {
+		return AbstractDatabase;
+	}
+});

package/dist/{databases/cassandra_db.js → cassandra_db-C5K2zZew.js}

@@ -1,5 +1,5 @@
-require("../_virtual/_rolldown/runtime.js");
-const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+require("./chunk-8l464Juk.js");
+const require_AbstractDatabase = require("./AbstractDatabase-a4jdIEuT.js");
 let cassandra_driver = require("cassandra-driver");
 //#region databases/cassandra_db.ts
 /**
@@ -15,7 +15,7 @@ let cassandra_driver = require("cassandra-driver");
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-var Cassandra_db = class extends require_AbstractDatabase.default {
+var Cassandra_db = class extends require_AbstractDatabase.AbstractDatabase {
 	client;
 	pool;
 	/**

package/dist/{_virtual/_rolldown/runtime.js → chunk-8l464Juk.js}

@@ -20,4 +20,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-exports.__toESM = __toESM;
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/{databases/couch_db.js → couch_db-BVd81sS7.js}

@@ -1,9 +1,9 @@
-const require_runtime = require("../_virtual/_rolldown/runtime.js");
-const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_AbstractDatabase = require("./AbstractDatabase-a4jdIEuT.js");
 let http = require("http");
-http = require_runtime.__toESM(http);
+http = require_chunk.__toESM(http);
 let nano = require("nano");
-nano = require_runtime.__toESM(nano);
+nano = require_chunk.__toESM(nano);
 //#region databases/couch_db.ts
 /**
 * 2012 Max 'Azul' Wiehle
@@ -20,7 +20,7 @@ nano = require_runtime.__toESM(nano);
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-var Couch_db = class extends require_AbstractDatabase.default {
+var Couch_db = class extends require_AbstractDatabase.AbstractDatabase {
 	agent;
 	db;
 	constructor(settings) {

package/dist/{databases/dirty_db.js → dirty_db-C9zUhXIG.js}

@@ -1,7 +1,7 @@
-const require_runtime = require("../_virtual/_rolldown/runtime.js");
-const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_AbstractDatabase = require("./AbstractDatabase-a4jdIEuT.js");
 let dirty_ts = require("dirty-ts");
-dirty_ts = require_runtime.__toESM(dirty_ts);
+dirty_ts = require_chunk.__toESM(dirty_ts);
 //#region databases/dirty_db.ts
 /**
 * 2011 Peter 'Pita' Martischka
@@ -18,7 +18,7 @@ dirty_ts = require_runtime.__toESM(dirty_ts);
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-var dirty_db_default = class extends require_AbstractDatabase.default {
+var dirty_db_default = class extends require_AbstractDatabase.AbstractDatabase {
 	db;
 	constructor(settings) {
 		super(settings);

package/dist/{databases/dirty_git_db.js → dirty_git_db-Cj3oEEyZ.js}

@@ -1,7 +1,7 @@
-const require_runtime = require("../_virtual/_rolldown/runtime.js");
-const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_AbstractDatabase = require("./AbstractDatabase-a4jdIEuT.js");
 let dirty_ts = require("dirty-ts");
-dirty_ts = require_runtime.__toESM(dirty_ts);
+dirty_ts = require_chunk.__toESM(dirty_ts);
 let node_path = require("node:path");
 let simple_git = require("simple-git");
 //#region databases/dirty_git_db.ts
@@ -20,7 +20,7 @@ let simple_git = require("simple-git");
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-var dirty_git_db_default = class extends require_AbstractDatabase.default {
+var dirty_git_db_default = class extends require_AbstractDatabase.AbstractDatabase {
 	db;
 	constructor(settings) {
 		super(settings);

package/dist/{databases/elasticsearch_db.js → elasticsearch_db-DjnZ1DHG.js}

@@ -1,7 +1,7 @@
-const require_runtime = require("../_virtual/_rolldown/runtime.js");
-const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_AbstractDatabase = require("./AbstractDatabase-a4jdIEuT.js");
 let assert = require("assert");
-assert = require_runtime.__toESM(assert);
+assert = require_chunk.__toESM(assert);
 let buffer = require("buffer");
 let crypto = require("crypto");
 let _elastic_elasticsearch = require("@elastic/elasticsearch");
@@ -103,7 +103,7 @@ const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
 		await Promise.all([...scrollIds.values()].map((scrollId) => client.clearScroll({ scroll_id: scrollId })));
 	}
 };
-var elasticsearch_db_default = class extends require_AbstractDatabase.default {
+var elasticsearch_db_default = class extends require_AbstractDatabase.AbstractDatabase {
 	_client;
 	_index;
 	_indexClean;

package/dist/index.js

@@ -3,10 +3,490 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-require("./_virtual/_rolldown/runtime.js");
-const require_CacheAndBufferLayer = require("./lib/CacheAndBufferLayer.js");
-const require_logging = require("./lib/logging.js");
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_logging = require("./logging-DmqnZRde.js");
 let util = require("util");
+util = require_chunk.__toESM(util);
+//#region lib/CacheAndBufferLayer.ts
+/**
+* 2011 Peter 'Pita' Martischka
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS-IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* This module is made for the case, you want to use a SQL-Based Databse or a KeyValue Database that
+* can only save strings(and no objects), as a JSON KeyValue Store.
+*
+* The idea of the dbWrapper is to provide following features:
+*
+*   * automatic JSON serialize/deserialize to abstract that away from the database driver and the
+*     module user.
+*   * cache reads. A amount of KeyValues are hold in the memory, so that reading is faster.
+*   * Buffer DB Writings. Sets and deletes should be buffered to make them in a setted interval
+*     with a bulk. This reduces the overhead of database transactions and makes the database
+*     faster. But there is also a danger to loose data integrity, to keep that, we should provide a
+*     flush function.
+*
+* All Features can be disabled or configured. The Wrapper provides default settings that can be
+* overwriden by the driver and by the module user.
+*/
+/**
+* Cache with Least Recently Used eviction policy.
+*/
+var LRU = class {
+	/**
+	* @param evictable Optional predicate that dictates whether it is permissable to evict the entry
+	*     if it is old and the cache is over capacity. The predicate is passed two arguments (key,
+	*     value). If no predicate is provided, all entries are evictable. Warning: Non-evictable
+	*     entries can cause the cache to go over capacity. If the number of non-evictable entries is
+	*     greater than or equal to the capacity, all new evictable entries will be evicted
+	*     immediately.
+	*/
+	constructor(capacity, evictable = (k, v) => true) {
+		this._capacity = capacity;
+		this._evictable = evictable;
+		this._cache = /* @__PURE__ */ new Map();
+	}
+	/**
+	* The entries accessed via this iterator are not considered to have been "used" (for purposes of
+	* determining least recently used).
+	*/
+	[Symbol.iterator]() {
+		return this._cache.entries();
+	}
+	/**
+	* @param isUse Optional boolean indicating whether this get() should be considered a "use" of the
+	*     entry (for determining least recently used). Defaults to true.
+	* @returns undefined if there is no entry matching the given key.
+	*/
+	get(k, isUse = true) {
+		if (!this._cache.has(k)) return;
+		const v = this._cache.get(k);
+		if (isUse) {
+			this._cache.delete(k);
+			this._cache.set(k, v);
+		}
+		return v;
+	}
+	/**
+	* Adds or updates an entry in the cache. This marks the entry as the most recently used entry.
+	*/
+	set(k, v) {
+		this._cache.delete(k);
+		this._cache.set(k, v);
+		this.evictOld();
+	}
+	/**
+	* Evicts the oldest evictable entries until the number of entries is equal to or less than the
+	* cache's capacity. This method is automatically called by set(). Call this if you need to evict
+	* newly evictable entries before the next call to set().
+	*/
+	evictOld() {
+		for (const [k, v] of this._cache.entries()) {
+			if (this._cache.size <= this._capacity) break;
+			if (!this._evictable(k, v)) continue;
+			this._cache.delete(k);
+		}
+	}
+};
+var SelfContainedPromise = class extends Promise {
+	constructor(executor = null) {
+		let done;
+		super((resolve, reject) => {
+			done = (err, val) => err != null ? reject(err) : resolve(val);
+			if (executor != null) executor(resolve, reject);
+		});
+		this.done = done;
+	}
+};
+const defaultSettings = {
+	bulkLimit: 0,
+	cache: 1e4,
+	writeInterval: 100,
+	json: true,
+	charset: "utf8mb4"
+};
+const Database$1 = class {
+	/**
+	* @param wrappedDB The Database that should be wrapped
+	* @param settings (optional) The settings that should be applied to the wrapper
+	*/
+	constructor(wrappedDB, settings, logger) {
+		if (wrappedDB.isAsync) this.wrappedDB = wrappedDB;
+		else {
+			this.wrappedDB = {};
+			for (const fn of [
+				"close",
+				"doBulk",
+				"findKeys",
+				"get",
+				"init",
+				"remove",
+				"set"
+			]) {
+				const f = wrappedDB[fn];
+				if (typeof f !== "function") continue;
+				this.wrappedDB[fn] = util.default.promisify(f.bind(wrappedDB));
+			}
+		}
+		this.logger = logger;
+		this.settings = Object.freeze({
+			...defaultSettings,
+			...wrappedDB.settings || {},
+			...settings || {}
+		});
+		this.buffer = new LRU(this.settings.cache, (k, v) => !v.dirty && !v.writingInProgress);
+		this._flushPaused = null;
+		this._locks = /* @__PURE__ */ new Map();
+		this.metrics = {
+			lockAwaits: 0,
+			lockAcquires: 0,
+			lockReleases: 0,
+			reads: 0,
+			readsFailed: 0,
+			readsFinished: 0,
+			readsFromCache: 0,
+			readsFromDb: 0,
+			readsFromDbFailed: 0,
+			readsFromDbFinished: 0,
+			writes: 0,
+			writesFailed: 0,
+			writesFinished: 0,
+			writesObsoleted: 0,
+			writesToDb: 0,
+			writesToDbFailed: 0,
+			writesToDbFinished: 0,
+			writesToDbRetried: 0
+		};
+		this.flushInterval = this.settings.writeInterval > 0 ? setInterval(() => this.flush(), this.settings.writeInterval) : null;
+	}
+	async _lock(key) {
+		while (true) {
+			const l = this._locks.get(key);
+			if (l == null) break;
+			++this.metrics.lockAwaits;
+			await l;
+		}
+		++this.metrics.lockAcquires;
+		this._locks.set(key, new SelfContainedPromise());
+	}
+	async _unlock(key) {
+		++this.metrics.lockReleases;
+		this._locks.get(key).done();
+		this._locks.delete(key);
+	}
+	_pauseFlush() {
+		if (this._flushPaused == null) {
+			this._flushPaused = new SelfContainedPromise();
+			this._flushPaused.count = 0;
+		}
+		++this._flushPaused.count;
+	}
+	_resumeFlush() {
+		if (--this._flushPaused.count > 0) return;
+		this._flushPaused.done();
+		this._flushPaused = null;
+	}
+	/**
+	* wraps the init function of the original DB
+	*/
+	async init() {
+		await this.wrappedDB.init();
+	}
+	/**
+	* wraps the close function of the original DB
+	*/
+	async close() {
+		clearInterval(this.flushInterval);
+		await this.flush();
+		await this.wrappedDB.close();
+		this.wrappedDB = null;
+	}
+	/**
+	* Gets the value trough the wrapper.
+	*/
+	async get(key) {
+		let v;
+		await this._lock(key);
+		try {
+			v = await this._getLocked(key);
+		} finally {
+			this._unlock(key);
+		}
+		return clone(v);
+	}
+	async _getLocked(key) {
+		++this.metrics.reads;
+		try {
+			const entry = this.buffer.get(key);
+			if (entry != null) {
+				++this.metrics.readsFromCache;
+				if (this.logger.isDebugEnabled()) this.logger.debug(`GET    - ${key} - ${JSON.stringify(entry.value)} - from ${entry.dirty ? "dirty buffer" : "cache"}`);
+				return entry.value;
+			}
+			let value;
+			++this.metrics.readsFromDb;
+			try {
+				value = await this.wrappedDB.get(key);
+			} catch (err) {
+				++this.metrics.readsFromDbFailed;
+				throw err;
+			} finally {
+				++this.metrics.readsFromDbFinished;
+			}
+			if (this.settings.json) try {
+				value = JSON.parse(value);
+			} catch (err) {
+				this.logger.error(`JSON-PROBLEM:${value}`);
+				throw err;
+			}
+			if (this.settings.cache > 0) this.buffer.set(key, {
+				value,
+				dirty: null,
+				writingInProgress: false
+			});
+			if (this.logger.isDebugEnabled()) this.logger.debug(`GET    - ${key} - ${JSON.stringify(value)} - from database `);
+			return value;
+		} catch (err) {
+			++this.metrics.readsFailed;
+			throw err;
+		} finally {
+			++this.metrics.readsFinished;
+		}
+	}
+	/**
+	* Find keys function searches the db sets for matching entries and
+	* returns the key entries via callback.
+	*/
+	async findKeys(key, notKey) {
+		await this.flush();
+		const keyValues = await this.wrappedDB.findKeys(key, notKey);
+		if (this.logger.isDebugEnabled()) this.logger.debug(`GET    - ${key}-${notKey} - ${JSON.stringify(keyValues)} - from database `);
+		return clone(keyValues);
+	}
+	/**
+	* Remove a record from the database
+	*/
+	async remove(key) {
+		if (this.logger.isDebugEnabled()) this.logger.debug(`DELETE - ${key} - from database `);
+		await this.set(key, null);
+	}
+	/**
+	* Sets the value trough the wrapper
+	*/
+	async set(key, value) {
+		value = clone(value);
+		let p;
+		this._pauseFlush();
+		try {
+			await this._lock(key);
+			try {
+				p = this._setLocked(key, value);
+			} finally {
+				this._unlock(key);
+			}
+		} finally {
+			this._resumeFlush();
+		}
+		await p;
+	}
+	async _setLocked(key, value) {
+		++this.metrics.writes;
+		try {
+			let entry = this.buffer.get(key);
+			if (!entry || entry.writingInProgress) entry = {};
+			else if (entry.dirty) ++this.metrics.writesObsoleted;
+			entry.value = value;
+			if (!entry.dirty) entry.dirty = new SelfContainedPromise();
+			this.buffer.set(key, entry);
+			const buffered = this.settings.writeInterval > 0;
+			if (this.logger.isDebugEnabled()) this.logger.debug(`SET    - ${key} - ${JSON.stringify(value)} - to ${buffered ? "buffer" : "database"}`);
+			if (!buffered) this._write([[key, entry]]);
+			await entry.dirty;
+		} catch (err) {
+			++this.metrics.writesFailed;
+			throw err;
+		} finally {
+			++this.metrics.writesFinished;
+		}
+	}
+	/**
+	* Sets a subvalue
+	*/
+	async setSub(key, sub, value) {
+		value = clone(value);
+		if (this.logger.isDebugEnabled()) this.logger.debug(`SETSUB - ${key}${JSON.stringify(sub)} - ${JSON.stringify(value)}`);
+		let p;
+		this._pauseFlush();
+		try {
+			await this._lock(key);
+			try {
+				let base;
+				try {
+					const fullValue = await this._getLocked(key);
+					base = { fullValue };
+					const ptr = {
+						obj: base,
+						prop: "fullValue"
+					};
+					for (let i = 0; i < sub.length; i++) {
+						if (sub[i] === "__proto__") throw new Error("Modifying object prototype is not supported for security reasons");
+						let o = ptr.obj[ptr.prop];
+						if (o == null) ptr.obj[ptr.prop] = o = {};
+						if (typeof o !== "object") throw new TypeError(`Cannot set property ${JSON.stringify(sub[i])} on non-object ${JSON.stringify(o)} (key: ${JSON.stringify(key)} value in db: ${JSON.stringify(fullValue)} sub: ${JSON.stringify(sub.slice(0, i + 1))})`);
+						ptr.obj = ptr.obj[ptr.prop];
+						ptr.prop = sub[i];
+					}
+					if (value == null) delete ptr.obj[ptr.prop];
+					else ptr.obj[ptr.prop] = value;
+				} catch (err) {
+					++this.metrics.writes;
+					++this.metrics.writesFailed;
+					++this.metrics.writesFinished;
+					throw err;
+				}
+				p = this._setLocked(key, base.fullValue);
+			} finally {
+				await this._unlock(key);
+			}
+		} finally {
+			this._resumeFlush();
+		}
+		await p;
+	}
+	/**
+	* Returns a sub value of the object
+	* @param sub is a array, for example if you want to access object.test.bla, the array is ["test",
+	*     "bla"]
+	*/
+	async getSub(key, sub) {
+		await this._lock(key);
+		try {
+			let v = await this._getLocked(key);
+			for (const k of sub) {
+				if (typeof v !== "object" || v != null && !Object.prototype.hasOwnProperty.call(v, k) || k === "__proto__") v = null;
+				if (v == null) break;
+				v = v[k];
+			}
+			if (this.logger.isDebugEnabled()) this.logger.debug(`GETSUB - ${key}${JSON.stringify(sub)} - ${JSON.stringify(v)}`);
+			return clone(v);
+		} finally {
+			this._unlock(key);
+		}
+	}
+	/**
+	* Writes all dirty values to the database
+	*/
+	async flush() {
+		if (this._flushDone == null) this._flushDone = (async () => {
+			while (true) {
+				while (this._flushPaused != null) await this._flushPaused;
+				const dirtyEntries = [];
+				for (const entry of this.buffer) if (entry[1].dirty && !entry[1].writingInProgress) {
+					dirtyEntries.push(entry);
+					if (this.settings.bulkLimit && dirtyEntries.length >= this.settings.bulkLimit) break;
+				}
+				if (dirtyEntries.length === 0) return;
+				await this._write(dirtyEntries);
+			}
+		})();
+		await this._flushDone;
+		this._flushDone = null;
+	}
+	async _write(dirtyEntries) {
+		const markDone = (entry, err) => {
+			if (entry.writingInProgress) {
+				entry.writingInProgress = false;
+				if (err != null) ++this.metrics.writesToDbFailed;
+				++this.metrics.writesToDbFinished;
+			}
+			entry.dirty.done(err);
+			entry.dirty = null;
+		};
+		const ops = [];
+		const entries = [];
+		for (const [key, entry] of dirtyEntries) {
+			let value = entry.value;
+			try {
+				value = this.settings.json && value != null ? JSON.stringify(value) : clone(value);
+			} catch (err) {
+				markDone(entry, err);
+				continue;
+			}
+			entry.writingInProgress = true;
+			ops.push({
+				type: value == null ? "remove" : "set",
+				key,
+				value
+			});
+			entries.push(entry);
+		}
+		if (ops.length === 0) return;
+		this.metrics.writesToDb += ops.length;
+		const writeOneOp = async (op, entry) => {
+			let writeErr = null;
+			try {
+				switch (op.type) {
+					case "remove":
+						await this.wrappedDB.remove(op.key);
+						break;
+					case "set":
+						await this.wrappedDB.set(op.key, op.value);
+						break;
+					default: throw new Error(`unsupported operation type: ${op.type}`);
+				}
+			} catch (err) {
+				writeErr = err || new Error(err);
+			}
+			markDone(entry, writeErr);
+		};
+		if (ops.length === 1) await writeOneOp(ops[0], entries[0]);
+		else {
+			let success = false;
+			try {
+				await this.wrappedDB.doBulk(ops);
+				success = true;
+			} catch (err) {
+				this.logger.error(`Bulk write of ${ops.length} ops failed, retrying individually: ${err.stack || err}`);
+				this.metrics.writesToDbRetried += ops.length;
+				await Promise.all(ops.map(async (op, i) => await writeOneOp(op, entries[i])));
+			}
+			if (success) entries.forEach((entry) => markDone(entry, null));
+		}
+		this.buffer.evictOld();
+	}
+};
+const clone = (obj, key = "") => {
+	if (null == obj || "object" !== typeof obj) return obj;
+	if (typeof obj.toJSON === "function") return clone(obj.toJSON(key));
+	if (obj instanceof Date) {
+		const copy = /* @__PURE__ */ new Date();
+		copy.setTime(obj.getTime());
+		return copy;
+	}
+	if (obj instanceof Array) {
+		const copy = [];
+		for (let i = 0, len = obj.length; i < len; ++i) copy[i] = clone(obj[i], String(i));
+		return copy;
+	}
+	if (obj instanceof Object) {
+		const copy = {};
+		for (const attr in obj) if (Object.prototype.hasOwnProperty.call(obj, attr)) copy[attr] = clone(obj[attr], attr);
+		return copy;
+	}
+	throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+//#endregion
 //#region index.ts
 /**
 * 2011 Peter 'Pita' Martischka
@@ -45,7 +525,7 @@ for (const fn of [
 	"remove",
 	"set",
 	"setSub"
-]) if (fn in cbDb) cbDb[fn] = (0, util.callbackify)(require_CacheAndBufferLayer.Database.prototype[fn]);
+]) if (fn in cbDb) cbDb[fn] = (0, util.callbackify)(Database$1.prototype[fn]);
 const makeDoneCallback = (callback, deprecated) => (err) => {
 	if (callback) callback(err);
 	if (deprecated) deprecated(err);
@@ -84,7 +564,7 @@ var Database = class {
 	init(callback = null) {
 		const p = this.initDB().then((db) => {
 			db.logger = this.logger;
-			this.db = new require_CacheAndBufferLayer.Database(db, this.wrapperSettings, this.logger);
+			this.db = new Database$1(db, this.wrapperSettings, this.logger);
 			this.metrics = this.db.metrics;
 			return this.db.init();
 		});
@@ -93,23 +573,23 @@ var Database = class {
 	}
 	async initDB() {
 		switch (this.type) {
-			case "mysql": return new (await (Promise.resolve().then(() => require("./databases/mysql_db.js")))).default(this.dbSettings);
-			case "postgres": return new (await (Promise.resolve().then(() => require("./databases/postgres_db.js")))).default(this.dbSettings);
-			case "sqlite": return new (await (Promise.resolve().then(() => require("./databases/sqlite_db.js")))).default(this.dbSettings);
-			case "rustydb": return new (await (Promise.resolve().then(() => require("./databases/rusty_db.js")))).default(this.dbSettings);
-			case "mongodb": return new (await (Promise.resolve().then(() => require("./databases/mongodb_db.js")))).default(this.dbSettings);
-			case "redis": return new (await (Promise.resolve().then(() => require("./databases/redis_db.js")))).default(this.dbSettings);
-			case "cassandra": return new (await (Promise.resolve().then(() => require("./databases/cassandra_db.js")))).default(this.dbSettings);
-			case "dirty": return new (await (Promise.resolve().then(() => require("./databases/dirty_db.js")))).default(this.dbSettings);
-			case "dirtygit": return new (await (Promise.resolve().then(() => require("./databases/dirty_git_db.js")))).default(this.dbSettings);
-			case "elasticsearch": return new (await (Promise.resolve().then(() => require("./databases/elasticsearch_db.js")))).default(this.dbSettings);
-			case "memory": return new (await (Promise.resolve().then(() => require("./databases/memory_db.js")))).default(this.dbSettings);
-			case "mock": return new (await (Promise.resolve().then(() => require("./databases/mock_db.js")))).default(this.dbSettings);
-			case "mssql": return new (await (Promise.resolve().then(() => require("./databases/mssql_db.js")))).default(this.dbSettings);
-			case "postgrespool": return new (await (Promise.resolve().then(() => require("./databases/postgrespool_db.js")))).default(this.dbSettings);
-			case "rethink": return new (await (Promise.resolve().then(() => require("./databases/rethink_db.js")))).default(this.dbSettings);
-			case "couch": return new (await (Promise.resolve().then(() => require("./databases/couch_db.js")))).default(this.dbSettings);
-			case "surrealdb": return new (await (Promise.resolve().then(() => require("./databases/surrealdb_db.js")))).default(this.dbSettings);
+			case "mysql": return new (await (Promise.resolve().then(() => require("./mysql_db-CRYtP-Mk.js")))).default(this.dbSettings);
+			case "postgres": return new (await (Promise.resolve().then(() => require("./postgres_db-CVDQiNwN.js")))).default(this.dbSettings);
+			case "sqlite": return new (await (Promise.resolve().then(() => require("./sqlite_db-B-nmfVje.js")))).default(this.dbSettings);
+			case "rustydb": return new (await (Promise.resolve().then(() => require("./rusty_db-CaVGu0z7.js")))).default(this.dbSettings);
+			case "mongodb": return new (await (Promise.resolve().then(() => require("./mongodb_db-ByZscnbs.js")))).default(this.dbSettings);
+			case "redis": return new (await (Promise.resolve().then(() => require("./redis_db-CDma40om.js")))).default(this.dbSettings);
+			case "cassandra": return new (await (Promise.resolve().then(() => require("./cassandra_db-C5K2zZew.js")))).default(this.dbSettings);
+			case "dirty": return new (await (Promise.resolve().then(() => require("./dirty_db-C9zUhXIG.js")))).default(this.dbSettings);
+			case "dirtygit": return new (await (Promise.resolve().then(() => require("./dirty_git_db-Cj3oEEyZ.js")))).default(this.dbSettings);
+			case "elasticsearch": return new (await (Promise.resolve().then(() => require("./elasticsearch_db-DjnZ1DHG.js")))).default(this.dbSettings);
+			case "memory": return new (await (Promise.resolve().then(() => require("./memory_db-SlQsh4tk.js")))).default(this.dbSettings);
+			case "mock": return new (await (Promise.resolve().then(() => require("./mock_db-BBijMErd.js")))).default(this.dbSettings);
+			case "mssql": return new (await (Promise.resolve().then(() => require("./mssql_db-C9-gmVgP.js")))).default(this.dbSettings);
+			case "postgrespool": return new (await (Promise.resolve().then(() => require("./postgrespool_db-CynysVC1.js")))).default(this.dbSettings);
+			case "rethink": return new (await (Promise.resolve().then(() => require("./rethink_db-D7NvPe_4.js")))).default(this.dbSettings);
+			case "couch": return new (await (Promise.resolve().then(() => require("./couch_db-BVd81sS7.js")))).default(this.dbSettings);
+			case "surrealdb": return new (await (Promise.resolve().then(() => require("./surrealdb_db-JmcyCabz.js")))).default(this.dbSettings);
 			default: throw new Error("Invalid database type");
 		}
 	}