ueberdb2 5.0.42 → 5.0.44

package/dist/lib/CacheAndBufferLayer.js

@@ -1,484 +0,0 @@
-const require_runtime = require("../_virtual/_rolldown/runtime.js");
-let util = require("util");
-util = require_runtime.__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 = 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
-exports.Database = Database;