ueberdb2 5.0.38 → 5.0.40

package/dist/databases/surrealdb_db.js

@@ -0,0 +1,135 @@
+require("../_virtual/_rolldown/runtime.js");
+const require_AbstractDatabase = require("../lib/AbstractDatabase.js");
+let surrealdb = require("surrealdb");
+//#region databases/surrealdb_db.ts
+/**
+* 2023 Samuel Schwanzer
+*
+* 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.
+*/
+const DATABASE = "ueberdb";
+const WILDCARD = "*";
+const replaceAt = function(index, replacement, original) {
+	return original.substring(0, index) + replacement + original.substring(index + replacement.length);
+};
+const escapeKey = (key) => {
+	const index = key.indexOf(":");
+	if (index > -1) return replaceAt(index, "_", key);
+	return key;
+};
+const unescapeKey = (key, originalKey) => {
+	const index = originalKey.indexOf(":");
+	if (index > -1) return replaceAt(index, ":", key);
+	return key;
+};
+var SurrealDB = class extends require_AbstractDatabase.default {
+	_client;
+	constructor(settings) {
+		super(settings);
+		this._client = null;
+	}
+	get isAsync() {
+		return true;
+	}
+	async init() {
+		if (this.settings.url) {
+			this._client = new surrealdb.Surreal();
+			await this._client.connect(this.settings.url);
+		} else if (this.settings.host) {
+			const port = this.settings.port || 8e3;
+			const protocol = this.settings.clientOptions?.protocol || "http://";
+			const path = this.settings.clientOptions?.path || "/rpc";
+			const host = this.settings.host;
+			this._client = new surrealdb.Surreal();
+			await this._client.connect(`${protocol}${host}:${port}${path}`);
+		}
+		if (this.settings.user && this.settings.password) await this._client.signin({
+			username: this.settings.user,
+			password: this.settings.password
+		});
+		await this._client.use({
+			namespace: DATABASE,
+			database: DATABASE
+		});
+	}
+	async get(key) {
+		if (this._client == null) return null;
+		key = escapeKey(key);
+		const rows = (await this._client.query("SELECT key, value FROM store WHERE key = $key", { key }))[0] || [];
+		if (rows.length === 0) return null;
+		const row = rows[0];
+		if (typeof row === "string") return row;
+		return unescapeKey(row.value, key);
+	}
+	async findKeys(key, notKey) {
+		if (this._client == null) return null;
+		const queryString = notKey != null ? `SELECT key FROM store WHERE ${this.transformWildcard(key, "key")} AND ${this.transformWildcardNegative(notKey, "notKey")}` : `SELECT key FROM store WHERE ${this.transformWildcard(key, "key")}`;
+		const cleanKey = key.replace(WILDCARD, "");
+		const cleanNotKey = (notKey || "").replace(WILDCARD, "");
+		const bindings = { key: cleanKey };
+		if (notKey != null) bindings.notKey = cleanNotKey;
+		const res = await this._client.query(queryString, bindings);
+		return this.transformResult(res[0] || [], cleanKey);
+	}
+	transformWildcard(key, keyExpr) {
+		if (key.startsWith(WILDCARD) && key.endsWith(WILDCARD)) return `${keyExpr} CONTAINS $${keyExpr}`;
+		else if (key.startsWith(WILDCARD)) return `string::ends_with(${keyExpr}, $${keyExpr})`;
+		else if (key.endsWith(WILDCARD)) return `string::starts_with(${keyExpr}, $${keyExpr})`;
+		else return `${keyExpr} = $${keyExpr}`;
+	}
+	transformWildcardNegative(key, keyExpr) {
+		if (key.startsWith(WILDCARD) && key.endsWith(WILDCARD)) return `key CONTAINSNOT $${keyExpr}`;
+		else if (key.startsWith(WILDCARD)) return `string::ends_with(key, $${keyExpr}) == false`;
+		else if (key.endsWith(WILDCARD)) return `string::starts_with(key, $${keyExpr}) == false`;
+		else return `key != $${keyExpr}`;
+	}
+	transformResult(rows, originalKey) {
+		const value = [];
+		if (typeof rows === "string") {
+			value.push(unescapeKey(rows, originalKey));
+			return value;
+		}
+		for (const row of rows) value.push(unescapeKey(row.key, originalKey));
+		return value;
+	}
+	async set(key, value) {
+		if (this._client == null) return null;
+		const exists = await this.get(key);
+		const escapedKey = escapeKey(key);
+		if (exists) await this._client.query("UPDATE store SET value = $value WHERE key = $key", {
+			key: escapedKey,
+			value
+		});
+		else await this._client.query("INSERT INTO store (key, value) VALUES ($key, $value)", {
+			key: escapedKey,
+			value
+		});
+	}
+	async remove(key) {
+		if (this._client == null) return null;
+		key = escapeKey(key);
+		return await this._client.query("DELETE FROM store WHERE key = $key", { key });
+	}
+	async doBulk(bulk) {
+		if (this._client == null) return null;
+		for (const b of bulk) if (b.type === "set") await this.set(b.key, b.value);
+		else if (b.type === "remove") await this.remove(b.key);
+	}
+	async close() {
+		if (this._client == null) return null;
+		await this._client.close();
+		this._client = null;
+	}
+};
+//#endregion
+exports.default = SurrealDB;

package/dist/index.d.ts

@@ -1,20 +1,4 @@
 import { Settings } from './lib/AbstractDatabase';
-import Cassandra_db from './databases/cassandra_db';
-import Couch_db from './databases/couch_db';
-import Dirty_db from './databases/dirty_db';
-import Dirty_git_db from './databases/dirty_git_db';
-import Elasticsearch_db from './databases/elasticsearch_db';
-import MemoryDB from './databases/memory_db';
-import Mock_db from './databases/mock_db';
-import Mongodb_db from './databases/mongodb_db';
-import MSSQL from './databases/mssql_db';
-import Mysql_db from './databases/mysql_db';
-import Postgres_db from './databases/postgres_db';
-import RedisDB from './databases/redis_db';
-import Rethink_db from './databases/rethink_db';
-import SQLiteDB from './databases/sqlite_db';
-import SurrealDB from './databases/surrealdb_db';
-import Rusty_db from "./databases/rusty_db";
 export type DatabaseType = 'mysql' | 'postgres' | 'sqlite' | 'rustydb' | 'mongodb' | 'redis' | 'cassandra' | 'dirty' | 'dirtygit' | 'elasticsearch' | 'memory' | 'mock' | 'mssql' | 'postgrespool' | 'rethink' | 'couch' | 'surrealdb';
 export declare class Database {
     readonly type: DatabaseType;
@@ -37,7 +21,7 @@ export declare class Database {
      * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
      */
     init(callback?: null): any;
-    initDB(): Cassandra_db | Couch_db | Dirty_db | Dirty_git_db | Elasticsearch_db | MemoryDB | Mock_db | Mongodb_db | MSSQL | Mysql_db | Postgres_db | RedisDB | Rethink_db | SQLiteDB | SurrealDB | Rusty_db;
+    initDB(): Promise<import("./databases/cassandra_db").default | import("./databases/mysql_db").default | import("./databases/postgres_db").default | import("./databases/sqlite_db").default | import("./databases/rusty_db").default | import("./databases/mongodb_db").default | import("./databases/redis_db").default | import("./databases/dirty_db").default | import("./databases/dirty_git_db").default | import("./databases/elasticsearch_db").default | import("./databases/memory_db").default | import("./databases/mock_db").default | import("./databases/mssql_db").default | import("./databases/rethink_db").default | import("./databases/couch_db").default | import("./databases/surrealdb_db").default>;
     /**
      * Wrapper functions
      */