ueberdb2 4.0.15 → 4.1.1

package/.github/workflows/npmpublish.yml

@@ -62,7 +62,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          node-version: 20
       - run: npm ci
       # Optional dependencies must be installed manually.
       - run: npm i sqlite3
@@ -92,7 +92,7 @@ jobs:
       -
         uses: actions/setup-node@v3
         with:
-          node-version: 16
+          node-version: 20
           registry-url: https://registry.npmjs.org/
           cache: 'npm'
       # This is required if the package has a prepare script that uses something
@@ -124,7 +124,7 @@ jobs:
       # back-to-back merges will cause the first merge's workflow to fail but
       # the second's will succeed.
       -
-        run: npm publish
+        run: npm run publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
       -

package/dist/databases/cassandra_db.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const AbstractDatabase_1 = __importDefault(require("../lib/AbstractDatabase"));
+const cassandra_driver_1 = __importDefault(require("cassandra-driver"));
+const Database = class Cassandra_db extends AbstractDatabase_1.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();
+        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) {
+        // Create a client
+        this.client = new cassandra_driver_1.default.Client(this.settings.clientOptions);
+        // Pass on log messages if a logger has been configured
+        if (this.settings.logger) {
+            this.client.on('log', this.settings.logger);
+        }
+        // Check whether our column family already exists and create it if necessary
+        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) {
+            // Get all the keys
+            cql = `SELECT key FROM "${this.settings.columnFamily}"`;
+            this.client && this.client.execute(cql, (err, result) => {
+                if (err) {
+                    return callback(err);
+                }
+                // Construct a regular expression based on the given key
+                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 === '*:*:*') {
+            // restrict key to format 'text:*'
+            const matches = /^([^:]+):\*$/.exec(key);
+            if (matches) {
+                // Get the 'text' bit out of the key and get all those keys from a special column.
+                // We can retrieve them from this column as we're duplicating them on .set/.remove
+                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, []);
+                        }
+                        const keys = result.rows.map((row) => row.data);
+                        return callback(null, keys);
+                    });
+            }
+            else {
+                const msg = 'Cassandra db only supports key patterns like pad:* when notKey is set to *:*:*';
+                return callback(new Error(msg), null);
+            }
+        }
+        else {
+            return callback(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) => {
+            // We support finding keys of the form `test:*`. If anything matches, we will try and save
+            // this
+            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);
+    }
+};
+exports.Database = Database;

package/dist/databases/couch_db.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const AbstractDatabase_1 = __importDefault(require("../lib/AbstractDatabase"));
+const http_1 = __importDefault(require("http"));
+const nano_1 = __importDefault(require("nano"));
+const Database = class Couch_db extends AbstractDatabase_1.default {
+    agent;
+    db;
+    constructor(settings) {
+        super();
+        this.agent = null;
+        this.db = null;
+        this.settings = settings;
+        // force some settings
+        // used by CacheAndBufferLayer.js
+        this.settings.cache = 1000;
+        this.settings.writeInterval = 100;
+        this.settings.json = false;
+    }
+    get isAsync() { return true; }
+    async init() {
+        this.agent = new http_1.default.Agent({
+            keepAlive: true,
+            maxSockets: this.settings.maxListeners || 1,
+        });
+        const coudhDBSettings = {
+            url: `http://${this.settings.host}:${this.settings.port}`,
+            requestDefaults: {
+                agent: this.agent,
+            },
+        };
+        if (this.settings.user && this.settings.password) {
+            coudhDBSettings.requestDefaults.auth = {
+                username: this.settings.user,
+                password: this.settings.password,
+            };
+        }
+        const client = (0, nano_1.default)(coudhDBSettings);
+        try {
+            if (this.settings.database != null) {
+                await client.db.get(this.settings.database);
+            }
+        }
+        catch (err) {
+            if (err.statusCode !== 404)
+                throw err;
+            if (this.settings.database != null) {
+                await client.db.create(this.settings.database);
+            }
+        }
+        if (this.settings.database != null) {
+            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);
+        const results = await this.db.find({
+            selector: {
+                _id: pfxLen < 0 ? pfx : {
+                    $gte: pfx,
+                    // https://docs.couchdb.org/en/3.2.2/ddocs/views/collation.html#string-ranges
+                    $lte: `${pfx}\ufff0`,
+                    $regex: this.createFindRegex(key, notKey).source,
+                },
+            },
+            fields: ['_id'],
+        });
+        return results.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,
+            // @ts-ignore
+            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;
+        }
+        // etag has additional quotation marks, remove them
+        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 = {};
+        // @ts-ignore
+        for (const { key, value } of (await this.db.fetchRevs({ keys })).rows) {
+            // couchDB will return error instead of value if key does not exist
+            if (value != null)
+                revs[key] = value.rev;
+        }
+        const setters = [];
+        for (const item of bulk) {
+            const set = { _id: item.key, _rev: undefined,
+                _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 && await this.db.bulk({ docs: setters });
+    }
+    async close() {
+        this.db = null;
+        if (this.agent)
+            this.agent.destroy();
+        this.agent = null;
+    }
+};
+exports.Database = Database;

package/dist/databases/dirty_db.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+/*
+*
+* Fair warning that length may not provide the correct value upon load.
+* See https://github.com/ether/etherpad-lite/pull/3984
+*
+*/
+const AbstractDatabase_1 = __importDefault(require("../lib/AbstractDatabase"));
+// @ts-ignore
+const dirty_1 = __importDefault(require("dirty"));
+const Database = class extends AbstractDatabase_1.default {
+    db;
+    constructor(settings) {
+        super();
+        this.db = null;
+        if (!settings || !settings.filename) {
+            // @ts-ignore
+            settings = { filename: null };
+        }
+        this.settings = settings;
+        // set default settings
+        this.settings.cache = 0;
+        this.settings.writeInterval = 0;
+        this.settings.json = false;
+    }
+    init(callback) {
+        this.db = new dirty_1.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);
+    }
+    remove(key, callback) {
+        this.db.rm(key, callback);
+    }
+    close(callback) {
+        this.db.close();
+        this.db = null;
+        if (callback)
+            callback();
+    }
+};
+exports.Database = Database;

package/dist/databases/dirty_git_db.js

@@ -0,0 +1,77 @@
+"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;
+const AbstractDatabase_1 = __importDefault(require("../lib/AbstractDatabase"));
+/**
+ * 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.
+ */
+// @ts-ignore
+const dirty_1 = require("dirty");
+const Database = class extends AbstractDatabase_1.default {
+    db;
+    constructor(settings) {
+        super();
+        // @ts-ignore
+        this.db = null;
+        if (!settings || !settings.filename) {
+            settings = {};
+        }
+        this.settings = settings;
+        // set default settings
+        this.settings.cache = 0;
+        this.settings.writeInterval = 0;
+        this.settings.json = false;
+    }
+    init(callback) {
+        this.db = new dirty_1.Dirty(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);
+        const databasePath = require('path').dirname(this.settings.filename);
+        require('simple-git')(databasePath)
+            .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();
+    }
+};
+exports.Database = Database;