ueberdb2 5.0.48 → 6.0.2

package/dist/index.js

@@ -1,12 +1,5 @@
-"use strict";
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
-const require_chunk = require("./chunk-8l464Juk.js");
-const require_logging = require("./logging-DmqnZRde.js");
-let util = require("util");
-util = require_chunk.__toESM(util);
+import { t as normalizeLogger } from "./logging-DOvFhjsQ.js";
+import { promisify } from "node:util";
 //#region lib/CacheAndBufferLayer.ts
 /**
 * 2011 Peter 'Pita' Martischka
@@ -23,54 +16,32 @@ util = require_chunk.__toESM(util);
 * 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.
-*/
+const defaultSettings = {
+	bulkLimit: 0,
+	cache: 1e4,
+	writeInterval: 100,
+	json: true,
+	charset: "utf8mb4"
+};
 var LRU = class {
+	_capacity;
+	_evictable;
+	_cache;
 	/**
 	* @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.
+	*     if it is old and the cache is over capacity. Warning: Non-evictable entries can cause the
+	*     cache to go over capacity.
 	*/
-	constructor(capacity, evictable = (k, v) => true) {
+	constructor(capacity, evictable = () => 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;
+		if (!this._cache.has(k)) return void 0;
 		const v = this._cache.get(k);
 		if (isUse) {
 			this._cache.delete(k);
@@ -78,19 +49,11 @@ var LRU = class {
 		}
 		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;
@@ -100,31 +63,31 @@ var LRU = class {
 	}
 };
 var SelfContainedPromise = class extends Promise {
+	done;
 	constructor(executor = null) {
 		let done;
 		super((resolve, reject) => {
-			done = (err, val) => err != null ? reject(err) : resolve(val);
-			if (executor != null) executor(resolve, reject);
+			done = (err) => err != null ? reject(err) : resolve();
+			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
-	*/
+var Database$1 = class {
+	wrappedDB;
+	logger;
+	settings;
+	buffer;
+	_flushPaused = null;
+	_flushPausedCount = 0;
+	_locks = /* @__PURE__ */ new Map();
+	_flushDone = null;
+	metrics;
+	flushInterval;
 	constructor(wrappedDB, settings, logger) {
 		if (wrappedDB.isAsync) this.wrappedDB = wrappedDB;
 		else {
-			this.wrappedDB = {};
+			const promisified = {};
 			for (const fn of [
 				"close",
 				"doBulk",
@@ -136,18 +99,17 @@ const Database$1 = class {
 			]) {
 				const f = wrappedDB[fn];
 				if (typeof f !== "function") continue;
-				this.wrappedDB[fn] = util.default.promisify(f.bind(wrappedDB));
+				promisified[fn] = promisify(f.bind(wrappedDB));
 			}
+			this.wrappedDB = promisified;
 		}
 		this.logger = logger;
 		this.settings = Object.freeze({
 			...defaultSettings,
-			...wrappedDB.settings || {},
-			...settings || {}
+			...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,
@@ -168,7 +130,9 @@ const Database$1 = class {
 			writesToDbFinished: 0,
 			writesToDbRetried: 0
 		};
-		this.flushInterval = this.settings.writeInterval > 0 ? setInterval(() => this.flush(), this.settings.writeInterval) : null;
+		this.flushInterval = this.settings.writeInterval > 0 ? setInterval(() => {
+			this.flush();
+		}, this.settings.writeInterval) : null;
 	}
 	async _lock(key) {
 		while (true) {
@@ -180,7 +144,7 @@ const Database$1 = class {
 		++this.metrics.lockAcquires;
 		this._locks.set(key, new SelfContainedPromise());
 	}
-	async _unlock(key) {
+	_unlock(key) {
 		++this.metrics.lockReleases;
 		this._locks.get(key).done();
 		this._locks.delete(key);
@@ -188,33 +152,24 @@ const Database$1 = class {
 	_pauseFlush() {
 		if (this._flushPaused == null) {
 			this._flushPaused = new SelfContainedPromise();
-			this._flushPaused.count = 0;
+			this._flushPausedCount = 0;
 		}
-		++this._flushPaused.count;
+		++this._flushPausedCount;
 	}
 	_resumeFlush() {
-		if (--this._flushPaused.count > 0) return;
+		if (--this._flushPausedCount > 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);
+		clearInterval(this.flushInterval ?? void 0);
 		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);
@@ -245,7 +200,7 @@ const Database$1 = class {
 				++this.metrics.readsFromDbFinished;
 			}
 			if (this.settings.json) try {
-				value = JSON.parse(value);
+				value = value != null ? JSON.parse(value) : null;
 			} catch (err) {
 				this.logger.error(`JSON-PROBLEM:${value}`);
 				throw err;
@@ -264,26 +219,16 @@ const Database$1 = class {
 			++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;
@@ -304,7 +249,11 @@ const Database$1 = class {
 		++this.metrics.writes;
 		try {
 			let entry = this.buffer.get(key);
-			if (!entry || entry.writingInProgress) entry = {};
+			if (!entry || entry.writingInProgress) entry = {
+				value: void 0,
+				dirty: null,
+				writingInProgress: false
+			};
 			else if (entry.dirty) ++this.metrics.writesObsoleted;
 			entry.value = value;
 			if (!entry.dirty) entry.dirty = new SelfContainedPromise();
@@ -320,9 +269,6 @@ const Database$1 = class {
 			++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)}`);
@@ -357,18 +303,13 @@ const Database$1 = class {
 				}
 				p = this._setLocked(key, base.fullValue);
 			} finally {
-				await this._unlock(key);
+				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 {
@@ -384,9 +325,6 @@ const Database$1 = class {
 			this._unlock(key);
 		}
 	}
-	/**
-	* Writes all dirty values to the database
-	*/
 	async flush() {
 		if (this._flushDone == null) this._flushDone = (async () => {
 			while (true) {
@@ -416,18 +354,19 @@ const Database$1 = class {
 		const ops = [];
 		const entries = [];
 		for (const [key, entry] of dirtyEntries) {
-			let value = entry.value;
+			let serialized;
 			try {
-				value = this.settings.json && value != null ? JSON.stringify(value) : clone(value);
+				if (this.settings.json && entry.value != null) serialized = JSON.stringify(entry.value);
+				else serialized = clone(entry.value);
 			} catch (err) {
 				markDone(entry, err);
 				continue;
 			}
 			entry.writingInProgress = true;
 			ops.push({
-				type: value == null ? "remove" : "set",
+				type: serialized == null ? "remove" : "set",
 				key,
-				value
+				value: serialized
 			});
 			entries.push(entry);
 		}
@@ -436,30 +375,24 @@ const Database$1 = class {
 		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}`);
-				}
+				if (op.type === "remove") await this.wrappedDB.remove(op.key);
+				else await this.wrappedDB.set(op.key, op.value);
 			} catch (err) {
-				writeErr = err || new Error(err);
+				writeErr = err instanceof Error ? err : new Error(String(err));
 			}
 			markDone(entry, writeErr);
 		};
 		if (ops.length === 1) await writeOneOp(ops[0], entries[0]);
+		else if (typeof this.wrappedDB.doBulk !== "function") await Promise.all(ops.map(async (op, i) => writeOneOp(op, entries[i])));
 		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.logger.error(`Bulk write of ${ops.length} ops failed, retrying individually: ${err.stack ?? String(err)}`);
 				this.metrics.writesToDbRetried += ops.length;
-				await Promise.all(ops.map(async (op, i) => await writeOneOp(op, entries[i])));
+				await Promise.all(ops.map(async (op, i) => writeOneOp(op, entries[i])));
 			}
 			if (success) entries.forEach((entry) => markDone(entry, null));
 		}
@@ -467,21 +400,17 @@ const Database$1 = class {
 	}
 };
 const clone = (obj, key = "") => {
-	if (null == obj || "object" !== typeof obj) return obj;
+	if (obj == null || typeof obj !== "object") 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 (Array.isArray(obj)) return obj.map((item, i) => clone(item, String(i)));
 	if (obj instanceof Object) {
 		const copy = {};
-		for (const attr in obj) if (Object.prototype.hasOwnProperty.call(obj, attr)) copy[attr] = clone(obj[attr], attr);
+		for (const attr of Object.keys(obj)) copy[attr] = clone(obj[attr], attr);
 		return copy;
 	}
 	throw new Error("Unable to copy obj! Its type isn't supported.");
@@ -504,48 +433,18 @@ const clone = (obj, key = "") => {
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-const cbDb = {
-	init: () => {},
-	flush: () => {},
-	set: () => {},
-	get: () => {},
-	remove: () => {},
-	findKeys: () => {},
-	close: () => {},
-	getSub: () => {},
-	setSub: () => {}
-};
-for (const fn of [
-	"close",
-	"findKeys",
-	"flush",
-	"get",
-	"getSub",
-	"init",
-	"remove",
-	"set",
-	"setSub"
-]) 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);
-	if (err != null && callback == null && deprecated == null) throw err;
-};
 var Database = class {
 	type;
 	dbSettings;
 	wrapperSettings;
-	logger;
+	_logger;
 	db;
 	metrics;
 	/**
 	* @param type The type of the database
 	* @param dbSettings The settings for that specific database type
-	* @param wrapperSettings
-	* @param logger Optional logger object. If no logger object is provided no logging will occur.
-	*     The logger object is expected to be a log4js logger object or `console`. A logger object
-	*     from another logging library should also work, but performance may be reduced if the logger
-	*     object does not have is${Level}Enabled() methods (isDebugEnabled(), etc.).
+	* @param wrapperSettings Cache/buffer layer settings (cache size, write interval, etc.)
+	* @param logger Optional logger (log4js, console, or any object with debug/info/warn/error methods)
 	*/
 	constructor(type, dbSettings, wrapperSettings, logger = null) {
 		if (!type) {
@@ -555,141 +454,66 @@ var Database = class {
 		}
 		this.type = type;
 		this.dbSettings = dbSettings;
-		this.wrapperSettings = wrapperSettings;
-		this.logger = require_logging.normalizeLogger(logger);
+		this.wrapperSettings = wrapperSettings ?? null;
+		this._logger = normalizeLogger(logger);
 	}
-	/**
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	init(callback = null) {
-		const p = this.initDB().then((db) => {
-			db.logger = this.logger;
-			this.db = new Database$1(db, this.wrapperSettings, this.logger);
-			this.metrics = this.db.metrics;
-			return this.db.init();
-		});
-		if (callback != null) return cbDb.init.call({ init: () => p });
-		return p;
+	async init() {
+		const db = await this.initDB();
+		db.logger = this._logger;
+		this.db = new Database$1(db, this.wrapperSettings, this._logger);
+		this.metrics = this.db.metrics;
+		await this.db.init();
 	}
 	async initDB() {
 		switch (this.type) {
-			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");
+			case "mysql": return new (await (import("./mysql_db-48mMBbKZ.js"))).default(this.dbSettings);
+			case "postgres": return new (await (import("./postgres_db-7Hiezhpi.js"))).default(this.dbSettings);
+			case "sqlite": return new (await (import("./sqlite_db-Cy8OT62U.js"))).default(this.dbSettings);
+			case "rustydb": return new (await (import("./rusty_db-Msjxckfm.js"))).default(this.dbSettings);
+			case "mongodb": return new (await (import("./mongodb_db-DgkIuEMZ.js"))).default(this.dbSettings);
+			case "redis": return new (await (import("./redis_db-DKRC8sR9.js"))).default(this.dbSettings);
+			case "cassandra": return new (await (import("./cassandra_db-B_5ANRzM.js"))).default(this.dbSettings);
+			case "dirty": return new (await (import("./dirty_db-CocfsG5w.js"))).default(this.dbSettings);
+			case "dirtygit": return new (await (import("./dirty_git_db-BYnH74Hk.js"))).default(this.dbSettings);
+			case "elasticsearch": return new (await (import("./elasticsearch_db-C6G-Wnou.js"))).default(this.dbSettings);
+			case "memory": return new (await (import("./memory_db-CGTi0Ck-.js"))).default(this.dbSettings);
+			case "mock": return new (await (import("./mock_db-DCUmGtUq.js"))).default(this.dbSettings);
+			case "mssql": return new (await (import("./mssql_db-LiEvv4Sm.js"))).default(this.dbSettings);
+			case "postgrespool": return new (await (import("./postgrespool_db-CdF-1S34.js"))).default(this.dbSettings);
+			case "rethink": return new (await (import("./rethink_db-BGxY_SA3.js"))).default(this.dbSettings);
+			case "couch": return new (await (import("./couch_db-BXyzauwJ.js"))).default(this.dbSettings);
+			case "surrealdb": return new (await (import("./surrealdb_db-XnhMQEwL.js"))).default(this.dbSettings);
+			default: throw new Error(`Invalid database type: ${this.type}`);
 		}
 	}
-	/**
-	* Wrapper functions
-	*/
-	/**
-	* Deprecated synonym of flush().
-	*
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	doShutdown(callback = null) {
-		return this.flush(callback);
-	}
-	/**
-	* Writes any unsaved changes to the underlying database.
-	*
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	flush(callback = null) {
-		if (!cbDb || !cbDb.flush === void 0) return null;
-		if (callback != null) return cbDb.flush.call(this.db, callback);
+	async flush() {
 		return this.db.flush();
 	}
-	/**
-	* @param key
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	get(key, callback = null) {
-		if (callback != null) return cbDb.get.call(this.db, key, callback);
+	/** @deprecated Use flush() */
+	doShutdown() {
+		return this.flush();
+	}
+	async get(key) {
 		return this.db.get(key);
 	}
-	/**
-	* @param key
-	* @param notKey
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	findKeys(key, notKey, callback = null) {
-		if (callback != null) return cbDb.findKeys.call(this.db, key, notKey, callback);
+	async findKeys(key, notKey) {
 		return this.db.findKeys(key, notKey);
 	}
-	/**
-	* Removes an entry from the database if present.
-	*
-	* @param key
-	* @param cb Deprecated. Node-style callback. Called when the write has been committed to the
-	*     underlying database driver. If null, a Promise is returned.
-	* @param deprecated Deprecated callback that is called just after cb. Ignored if cb is null.
-	*/
-	remove(key, cb = null, deprecated = null) {
-		if (cb != null) return cbDb.remove.call(this.db, key, makeDoneCallback(cb, deprecated));
+	async remove(key) {
 		return this.db.remove(key);
 	}
-	/**
-	* Adds or changes the value of an entry.
-	*
-	* @param key
-	* @param value
-	* @param cb Deprecated. Node-style callback. Called when the write has been committed to the
-	*     underlying database driver. If null, a Promise is returned.
-	* @param deprecated Deprecated callback that is called just after cb. Ignored if cb is null.
-	*/
-	set(key, value, cb = null, deprecated = null) {
-		if (cb != null) return cbDb.set.call(this.db, key, value, makeDoneCallback(cb, deprecated));
+	async set(key, value) {
 		return this.db.set(key, value);
 	}
-	/**
-	* @param key
-	* @param sub
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	getSub(key, sub, callback = null) {
-		if (callback != null) return cbDb.getSub.call(this.db, key, sub, callback);
+	async getSub(key, sub) {
 		return this.db.getSub(key, sub);
 	}
-	/**
-	* Adds or changes a subvalue of an entry.
-	*
-	* @param key
-	* @param sub
-	* @param value
-	* @param cb Deprecated. Node-style callback. Called when the write has been committed to the
-	*     underlying database driver. If null, a Promise is returned.
-	* @param deprecated Deprecated callback that is called just after cb. Ignored if cb is null.
-	*/
-	setSub(key, sub, value, cb = null, deprecated = null) {
-		if (cb != null) return cbDb.setSub.call(this.db, key, sub, value, makeDoneCallback(cb, deprecated));
+	async setSub(key, sub, value) {
 		return this.db.setSub(key, sub, value);
 	}
-	/**
-	* Flushes unwritten changes then closes the connection to the underlying database. After this
-	* returns, any future call to a method on this object may result in an error.
-	*
-	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
-	*/
-	close(callback = null) {
-		if (callback != null) return cbDb.close.call(this.db, callback);
+	async close() {
 		return this.db.close();
 	}
 };
 //#endregion
-exports.Database = Database;
-exports.default = Database;
+export { Database, Database as default };