ueberdb2 4.0.11 → 4.0.17

package/dist/databases/sqlite_db.js

@@ -0,0 +1,140 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+/**
+ * 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.
+ */
+let SQDB;
+try {
+    SQDB = require('sqlite3').Database;
+}
+catch (err) {
+    throw new Error('sqlite3 not found. It was removed from ueberdb\'s dependencies because it requires ' +
+        'compilation which fails on several systems. If you still want to use sqlite, run ' +
+        '"npm install sqlite3" in your etherpad-lite ./src directory.');
+}
+const AbstractDatabase_1 = __importDefault(require("../lib/AbstractDatabase"));
+const util_1 = __importDefault(require("util"));
+const escape = (val) => `'${val.replace(/'/g, "''")}'`;
+const Database = class SQLiteDB extends AbstractDatabase_1.default {
+    db;
+    constructor(settings) {
+        super();
+        this.db = null;
+        if (!settings || !settings.filename) {
+            settings = { filename: ':memory:' };
+        }
+        this.settings = settings;
+        // set settings for the dbWrapper
+        if (settings.filename === ':memory:') {
+            this.settings.cache = 0;
+            this.settings.writeInterval = 0;
+            this.settings.json = true;
+        }
+        else {
+            this.settings.cache = 1000;
+            this.settings.writeInterval = 100;
+            this.settings.json = true;
+        }
+    }
+    init(callback) {
+        util_1.default.callbackify(async () => {
+            this.db = new SQDB(this.settings.filename);
+            await this._query('CREATE TABLE IF NOT EXISTS store (key TEXT PRIMARY KEY, value TEXT)');
+            // @ts-ignore
+        })(callback);
+    }
+    async _query(sql, params = []) {
+        // It is unclear how util.promisify() deals with variadic functions, so it is not used here.
+        return await new Promise((resolve, reject) => {
+            // According to sqlite3's documentation, .run() method (and maybe .all() and .get(); the
+            // documentation is unclear) might call the callback multiple times. That's OK -- ECMAScript
+            // guarantees that it is safe to call a Promise executor's resolve and reject functions
+            // multiple times. The subsequent calls are ignored, except Node.js's 'process' object emits a
+            // 'multipleResolves' event to aid in debugging.
+            this.db && this.db.all(sql, params, (err, rows) => {
+                if (err != null)
+                    return reject(err);
+                resolve(rows);
+            });
+        });
+    }
+    // Temporary callbackified version of _query. This will be removed once all database objects are
+    // asyncified.
+    _queryCb(sql, params, callback) {
+        // It is unclear how util.callbackify() handles optional parameters, so it is not used here.
+        const p = this._query(sql, params);
+        if (callback)
+            p.then((rows) => callback(null, rows), (err) => callback(err || new Error(err)));
+    }
+    get(key, callback) {
+        this._queryCb('SELECT value FROM store WHERE key = ?', [key], (err, rows) => callback(err, err == null && rows && rows.length ? rows[0].value : null));
+    }
+    findKeys(key, notKey, callback) {
+        let query = 'SELECT key FROM store WHERE key LIKE ?';
+        const params = [];
+        // desired keys are %key:%, e.g. pad:%
+        key = key.replace(/\*/g, '%');
+        params.push(key);
+        if (notKey != null) {
+            // not desired keys are notKey:%, e.g. %:%:%
+            notKey = notKey.replace(/\*/g, '%');
+            query += ' AND key NOT LIKE ?';
+            params.push(notKey);
+        }
+        this._queryCb(query, params, (err, results) => {
+            const value = [];
+            if (!err && Object.keys(results).length > 0) {
+                results.forEach((val) => {
+                    value.push(val.key);
+                });
+            }
+            callback(err, value);
+        });
+    }
+    set(key, value, callback) {
+        this._queryCb('REPLACE INTO store VALUES (?,?)', [key, value], callback);
+    }
+    remove(key, callback) {
+        this._queryCb('DELETE FROM store WHERE key = ?', [key], callback);
+    }
+    doBulk(bulk, callback) {
+        let sql = 'BEGIN TRANSACTION;\n';
+        for (const i in bulk) {
+            if (bulk[i].type === 'set') {
+                sql += `REPLACE INTO store VALUES (${escape(bulk[i].key)}, ${escape(bulk[i].value)});\n`;
+            }
+            else if (bulk[i].type === 'remove') {
+                sql += `DELETE FROM store WHERE key = ${escape(bulk[i].key)};\n`;
+            }
+        }
+        sql += 'END TRANSACTION;';
+        this.db && this.db.exec(sql, (err) => {
+            if (err) {
+                console.error('ERROR WITH SQL: ');
+                console.error(sql);
+            }
+            callback(err);
+        });
+    }
+    close(callback) {
+        callback();
+        this.db && this.db.close((err) => callback(err));
+    }
+};
+exports.Database = Database;

package/dist/index.js

@@ -0,0 +1,215 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+/**
+ * 2011 Peter 'Pita' Martischka
+ * 2020 John McLear
+ *
+ * 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.
+ */
+// @ts-ignore
+const CacheAndBufferLayer_1 = __importDefault(require("./lib/CacheAndBufferLayer"));
+const logging_1 = require("./lib/logging");
+const util_1 = require("util");
+const cbDb = {
+    init: () => { },
+    flush: () => { },
+    get: () => { },
+    remove: () => { },
+    findKeys: () => { },
+    close: () => { },
+    getSub: () => { },
+    setSub: () => { },
+};
+const fns = ['close', 'findKeys', 'flush', 'get', 'getSub', 'init', 'remove', 'set', 'setSub'];
+for (const fn of fns) { // @ts-ignore
+    cbDb[fn] = (0, util_1.callbackify)(CacheAndBufferLayer_1.default.Database.prototype[fn]);
+}
+const makeDoneCallback = (callback, deprecated) => (err) => {
+    if (callback)
+        callback(err);
+    if (deprecated)
+        deprecated(err);
+    if (err != null && callback == null && deprecated == null)
+        throw err;
+};
+const Database = class {
+    type;
+    dbModule;
+    dbSettings;
+    wrapperSettings;
+    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.).
+     */
+    constructor(type, dbSettings, wrapperSettings, logger = null) {
+        if (!type) {
+            type = 'sqlite';
+            dbSettings = null;
+            wrapperSettings = null;
+        }
+        // saves all settings and require the db module
+        this.type = type;
+        this.dbModule = require(`./databases/${type}_db`);
+        this.dbSettings = dbSettings;
+        this.wrapperSettings = wrapperSettings;
+        this.logger = (0, logging_1.normalizeLogger)(logger);
+        const db = new this.dbModule.Database(this.dbSettings);
+        db.logger = this.logger;
+        this.db = new CacheAndBufferLayer_1.default.Database(db, this.wrapperSettings, this.logger);
+        // Expose the cache wrapper's metrics to the user. See lib/CacheAndBufferLayer.js for details.
+        //
+        // WARNING: This feature is EXPERIMENTAL -- do not assume it will continue to exist in its
+        // current form in a future version.
+        this.metrics = this.db.metrics;
+    }
+    /**
+     * @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
+     */
+    init(callback = null) {
+        if (callback != null) {
+            return cbDb.init.call(this.db);
+        }
+        return this.db.init();
+    }
+    /**
+     * 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 === undefined)
+            return null;
+        if (callback != null) { // @ts-ignore
+            return cbDb.flush.call(this.db, callback);
+        }
+        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) { // @ts-ignore
+            return cbDb.get.call(this.db, key, callback);
+        }
+        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) { // @ts-ignore
+            return cbDb.findKeys.call(this.db, key, notKey, callback);
+        }
+        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) { // @ts-ignore
+            return cbDb.remove.call(this.db, key, makeDoneCallback(cb, deprecated));
+        }
+        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) { // @ts-ignore
+            return cbDb.get.call(this.db, key, value, makeDoneCallback(cb, deprecated));
+        }
+        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) { // @ts-ignore
+            return cbDb.getSub.call(this.db, key, sub, callback);
+        }
+        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) {
+            // @ts-ignore
+            return cbDb.setSub.call(this.db, key, sub, value, makeDoneCallback(cb, deprecated));
+        }
+        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) { // @ts-ignore
+            return cbDb.close.call(this.db, callback);
+        }
+        return this.db.close();
+    }
+};
+exports.Database = Database;
+/**
+ * Deprecated synonym of Database.
+ */
+exports.database = exports.Database;

package/dist/lib/AbstractDatabase.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logging_1 = require("./logging");
+const nullLogger = (0, logging_1.normalizeLogger)(null);
+// Format: All characters match themselves except * matches any zero or more characters. No
+// backslash escaping is supported, so it is impossible to create a pattern that matches only the
+// '*' character.
+const simpleGlobToRegExp = (s) => s.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+class AbstractDatabase {
+    logger;
+    // @ts-ignore
+    settings;
+    constructor() {
+        if (new.target === module.exports) {
+            throw new TypeError('cannot instantiate Abstract Database directly');
+        }
+        for (const fn of ['init', 'close', 'get', 'findKeys', 'remove', 'set']) {
+            // @ts-ignore
+            if (typeof this[fn] !== 'function')
+                throw new TypeError(`method ${fn} not defined`);
+        }
+        this.logger = nullLogger;
+    }
+    /**
+     * For findKey regex. Used by document dbs like mongodb or dirty.
+     */
+    createFindRegex(key, notKey) {
+        let regex = `^(?=${simpleGlobToRegExp(key)}$)`;
+        if (notKey != null)
+            regex += `(?!${simpleGlobToRegExp(notKey)}$)`;
+        return new RegExp(regex);
+    }
+    doBulk(operations, cb) {
+        throw new Error('the doBulk method must be implemented if write caching is enabled');
+    }
+    get isAsync() { return false; }
+}
+exports.default = AbstractDatabase;