ueberdb2 5.0.39 → 5.0.40

package/dist/databases/cassandra_db.js

@@ -0,0 +1,190 @@
+require("../_virtual/_rolldown/runtime.js");
+const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+let cassandra_driver = require("cassandra-driver");
+//#region databases/cassandra_db.ts
+/**
+* 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.
+*/
+var Cassandra_db = class extends require_AbstractDatabase.default {
+	client;
+	pool;
+	/**
+	* @param {Object} settings The required settings object to initiate the Cassandra database
+	* @param {String[]} settings.clientOptions See
+	*     http://www.datastax.com/drivers/nodejs/2.0/global.html#ClientOptions for a full set of
+	*     options that can be used
+	* @param {String} settings.columnFamily The column family that should be used to store data. The
+	*     column family will be created if it doesn't exist
+	* @param {Function} [settings.logger] Function that will be used to pass on log events emitted by
+	*     the Cassandra driver. See https://github.com/datastax/nodejs-driver#logging for more
+	*     information
+	*/
+	constructor(settings) {
+		super(settings);
+		if (!settings.clientOptions) throw new Error("The Cassandra client options should be defined");
+		if (!settings.columnFamily) throw new Error("The Cassandra column family should be defined");
+		this.settings = { database: settings.database };
+		this.settings.clientOptions = settings.clientOptions;
+		this.settings.columnFamily = settings.columnFamily;
+		this.settings.logger = settings.logger;
+	}
+	/**
+	* Initializes the Cassandra client, connects to Cassandra and creates the CF if it didn't exist
+	* already
+	*
+	* @param  {Function}   callback        Standard callback method.
+	* @param  {Error}      callback.err    An error object (if any.)
+	*/
+	init(callback) {
+		this.client = new cassandra_driver.Client(this.settings.clientOptions);
+		if (this.settings.logger) this.client.on("log", this.settings.logger);
+		this.client.execute("SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?", [this.settings.clientOptions.keyspace], (err, result) => {
+			if (err) return callback(err);
+			let isDefined = false;
+			const length = result.rows.length;
+			for (let i = 0; i < length; i++) if (result.rows[i].columnfamily_name === this.settings.columnFamily) {
+				isDefined = true;
+				break;
+			}
+			if (isDefined) return callback(null);
+			else {
+				const cql = `CREATE COLUMNFAMILY "${this.settings.columnFamily}" (key text PRIMARY KEY, data text)`;
+				this.client && this.client.execute(cql, callback);
+			}
+		});
+	}
+	/**
+	* Gets a value from Cassandra
+	*
+	* @param  {String}     key               The key for which the value should be retrieved
+	* @param  {Function}   callback          Standard callback method
+	* @param  {Error}      callback.err      An error object, if any
+	* @param  {String}     callback.value    The value for the given key (if any)
+	*/
+	get(key, callback) {
+		const cql = `SELECT data FROM "${this.settings.columnFamily}" WHERE key = ?`;
+		this.client && this.client.execute(cql, [key], (err, result) => {
+			if (err) return callback(err);
+			if (!result.rows || result.rows.length === 0) return callback(null, null);
+			return callback(null, result.rows[0].data);
+		});
+	}
+	/**
+	* Cassandra has no native `findKeys` method. This function implements a naive filter by
+	* retrieving *all* the keys and filtering those. This should obviously be used with the utmost
+	* care and is probably not something you want to run in production.
+	*
+	* @param  {String}     key               The filter for keys that should match
+	* @param  {String}     [notKey]          The filter for keys that shouldn't match
+	* @param  {Function}   callback          Standard callback method
+	* @param  {Error}      callback.err      An error object, if any
+	* @param  {String[]}   callback.keys     An array of keys that match the specified filters
+	*/
+	findKeys(key, notKey, callback) {
+		let cql = null;
+		if (!notKey) {
+			cql = `SELECT key FROM "${this.settings.columnFamily}"`;
+			this.client && this.client.execute(cql, (err, result) => {
+				if (err) return callback(err);
+				const regex = new RegExp(`^${key.replace(/\*/g, ".*")}$`);
+				const keys = [];
+				result.rows.forEach((row) => {
+					if (regex.test(row.key)) keys.push(row.key);
+				});
+				return callback(null, keys);
+			});
+		} else if (notKey === "*:*:*") {
+			const matches = /^([^:]+):\*$/.exec(key);
+			if (matches) {
+				cql = `SELECT * from "${this.settings.columnFamily}" WHERE key = ?`;
+				this.client && this.client.execute(cql, [`ueberdb:keys:${matches[1]}`], (err, result) => {
+					if (err) return callback(err);
+					if (!result.rows || result.rows.length === 0) return callback(null, []);
+					return callback(null, result.rows.map((row) => row.data));
+				});
+			} else return callback(/* @__PURE__ */ new Error("Cassandra db only supports key patterns like pad:* when notKey is set to *:*:*"), null);
+		} else return callback(/* @__PURE__ */ new Error("Cassandra db currently only supports *:*:* as notKey"), null);
+	}
+	/**
+	* Sets a value for a key
+	*
+	* @param  {String}     key             The key to set
+	* @param  {String}     value           The value associated to this key
+	* @param  {Function}   callback        Standard callback method
+	* @param  {Error}      callback.err    An error object, if any
+	*/
+	set(key, value, callback) {
+		this.doBulk([{
+			type: "set",
+			key,
+			value
+		}], callback);
+	}
+	/**
+	* Removes a key and it's value from the column family
+	*
+	* @param  {String}     key             The key to remove
+	* @param  {Function}   callback        Standard callback method
+	* @param  {Error}      callback.err    An error object, if any
+	*/
+	remove(key, callback) {
+		this.doBulk([{
+			type: "remove",
+			key
+		}], callback);
+	}
+	/**
+	* Performs multiple operations in one action
+	*
+	* @param  {Object[]}   bulk            The set of operations that should be performed
+	* @param  {Function}   callback        Standard callback method
+	* @param  {Error}      callback.err    An error object, if any
+	*/
+	doBulk(bulk, callback) {
+		const queries = [];
+		bulk.forEach((operation) => {
+			const matches = /^([^:]+):([^:]+)$/.exec(operation.key);
+			if (operation.type === "set") {
+				queries.push({
+					query: `UPDATE "${this.settings.columnFamily}" SET data = ? WHERE key = ?`,
+					params: [operation.value, operation.key]
+				});
+				if (matches) queries.push({
+					query: `UPDATE "${this.settings.columnFamily}" SET data = ? WHERE key = ?`,
+					params: ["1", `ueberdb:keys:${matches[1]}`]
+				});
+			} else if (operation.type === "remove") {
+				queries.push({
+					query: `DELETE FROM "${this.settings.columnFamily}" WHERE key=?`,
+					params: [operation.key]
+				});
+				if (matches) queries.push({
+					query: `DELETE FROM "${this.settings.columnFamily}" WHERE key = ?`,
+					params: [`ueberdb:keys:${matches[1]}`]
+				});
+			}
+		});
+		this.client && this.client.batch(queries, { prepare: true }, callback);
+	}
+	/**
+	* Closes the Cassandra connection
+	*
+	* @param  {Function}   callback        Standard callback method
+	* @param  {Error}      callback.err    Error object in case something goes wrong
+	*/
+	close(callback) {
+		this.pool.shutdown(callback);
+	}
+};
+//#endregion
+exports.default = Cassandra_db;

package/dist/databases/couch_db.js

@@ -0,0 +1,133 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+let http = require("http");
+http = require_runtime.__toESM(http);
+let nano = require("nano");
+nano = require_runtime.__toESM(nano);
+//#region databases/couch_db.ts
+/**
+* 2012 Max 'Azul' Wiehle
+*
+* 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.
+*/
+var Couch_db = class extends require_AbstractDatabase.default {
+	agent;
+	db;
+	constructor(settings) {
+		super(settings);
+		this.agent = null;
+		this.db = null;
+		this.settings = settings;
+		this.settings.cache = 1e3;
+		this.settings.writeInterval = 100;
+		this.settings.json = false;
+	}
+	get isAsync() {
+		return true;
+	}
+	async init() {
+		this.agent = new http.default.Agent({
+			keepAlive: true,
+			maxSockets: this.settings.maxListeners || 1
+		});
+		const client = (0, nano.default)({
+			url: `http://${this.settings.host}:${this.settings.port}`,
+			requestDefaults: { agent: this.agent }
+		});
+		if (this.settings.user && this.settings.password) await client.auth(this.settings.user, this.settings.password);
+		try {
+			await client.db.get(this.settings.database);
+		} catch (err) {
+			if (err.statusCode !== 404) throw err;
+			await client.db.create(this.settings.database);
+		}
+		this.db = client.use(this.settings.database);
+	}
+	async get(key) {
+		let doc;
+		try {
+			if (this.db) doc = await this.db.get(key);
+		} catch (err) {
+			if (err.statusCode === 404) return null;
+			throw err;
+		}
+		if (doc && "value" in doc) return doc.value;
+		return "";
+	}
+	async findKeys(key, notKey) {
+		const pfxLen = key.indexOf("*");
+		if (!this.db) return;
+		const pfx = pfxLen < 0 ? key : key.slice(0, pfxLen);
+		return (await this.db.find({
+			selector: { _id: pfxLen < 0 ? pfx : {
+				$gte: pfx,
+				$lte: `${pfx}\ufff0`,
+				$regex: this.createFindRegex(key, notKey).source
+			} },
+			fields: ["_id"]
+		})).docs.map((doc) => doc._id);
+	}
+	async set(key, value) {
+		let doc;
+		if (!this.db) return;
+		try {
+			doc = await this.db.get(key);
+		} catch (err) {
+			if (err.statusCode !== 404) throw err;
+		}
+		await this.db.insert({
+			_id: key,
+			value,
+			...doc == null ? {} : { _rev: doc._rev }
+		});
+	}
+	async remove(key) {
+		let header;
+		if (!this.db) return;
+		try {
+			header = await this.db.head(key);
+		} catch (err) {
+			if (err.statusCode === 404) return;
+			throw err;
+		}
+		const etag = JSON.parse(header.etag);
+		await this.db.destroy(key, etag);
+	}
+	async doBulk(bulk) {
+		if (!this.db) return;
+		const keys = bulk.map((op) => op.key);
+		const revs = {};
+		for (const { key, value } of (await this.db.fetchRevs({ keys })).rows) if (value != null) revs[key] = value.rev;
+		const setters = [];
+		for (const item of bulk) {
+			const set = {
+				_id: item.key,
+				_rev: void 0,
+				_deleted: false,
+				value: ""
+			};
+			if (revs[item.key] != null) set._rev = revs[item.key];
+			if (item.type === "set") set.value = item.value;
+			if (item.type === "remove") set._deleted = true;
+			setters.push(set);
+		}
+		await this.db.bulk({ docs: setters });
+	}
+	async close() {
+		this.db = null;
+		if (this.agent) this.agent.destroy();
+		this.agent = null;
+	}
+};
+//#endregion
+exports.default = Couch_db;

package/dist/databases/dirty_db.js

@@ -0,0 +1,62 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+let dirty_ts = require("dirty-ts");
+dirty_ts = require_runtime.__toESM(dirty_ts);
+//#region databases/dirty_db.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.
+*/
+var dirty_db_default = class extends require_AbstractDatabase.default {
+	db;
+	constructor(settings) {
+		super(settings);
+		this.db = null;
+		if (!settings || !settings.filename) settings = { filename: null };
+		this.settings = settings;
+		this.settings.cache = 0;
+		this.settings.writeInterval = 0;
+		this.settings.json = false;
+	}
+	init(callback) {
+		this.db = new dirty_ts.default(this.settings.filename);
+		this.db.on("load", () => {
+			callback();
+		});
+	}
+	get(key, callback) {
+		callback(null, this.db.get(key));
+	}
+	findKeys(key, notKey, callback) {
+		const keys = [];
+		const regex = this.createFindRegex(key, notKey);
+		this.db.forEach((key) => {
+			if (key.search(regex) !== -1) keys.push(key);
+		});
+		callback(null, keys);
+	}
+	set(key, value, callback) {
+		this.db.set(key, value, callback);
+	}
+	remove(key, callback) {
+		this.db.rm(key, callback);
+	}
+	close(callback) {
+		this.db.close();
+		this.db = null;
+		if (callback) callback();
+	}
+};
+//#endregion
+exports.default = dirty_db_default;

package/dist/databases/dirty_git_db.js

@@ -0,0 +1,68 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+let dirty_ts = require("dirty-ts");
+dirty_ts = require_runtime.__toESM(dirty_ts);
+let node_path = require("node:path");
+let simple_git = require("simple-git");
+//#region databases/dirty_git_db.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.
+*/
+var dirty_git_db_default = class extends require_AbstractDatabase.default {
+	db;
+	constructor(settings) {
+		super(settings);
+		this.db = null;
+		if (!settings || !settings.filename) settings = {};
+		this.settings = settings;
+		this.settings.cache = 0;
+		this.settings.writeInterval = 0;
+		this.settings.json = false;
+	}
+	init(callback) {
+		this.db = new dirty_ts.default(this.settings.filename);
+		this.db.on("load", (err) => {
+			callback();
+		});
+	}
+	get(key, callback) {
+		callback(null, this.db.get(key));
+	}
+	findKeys(key, notKey, callback) {
+		const keys = [];
+		const regex = this.createFindRegex(key, notKey);
+		this.db.forEach((key, val) => {
+			if (key.search(regex) !== -1) keys.push(key);
+		});
+		callback(null, keys);
+	}
+	set(key, value, callback) {
+		this.db.set(key, value, callback);
+		(0, simple_git.simpleGit)((0, node_path.dirname)(this.settings.filename)).silent(true).add("./*.db").commit("Automated commit...").push([
+			"-u",
+			"origin",
+			"master"
+		], () => console.debug("Stored git commit"));
+	}
+	remove(key, callback) {
+		this.db.rm(key, callback);
+	}
+	close(callback) {
+		this.db.close();
+		if (callback) callback();
+	}
+};
+//#endregion
+exports.default = dirty_git_db_default;