ueberdb2 4.1.23 → 4.1.26

package/dist/databases/couch_db.js

@@ -1,173 +0,0 @@
-'use strict';
-
-var AbstractDatabase = require('../lib/AbstractDatabase.js');
-var http = require('http');
-var nano = require('nano');
-
-/**
- * 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.
- */
-const Database = class Couch_db extends AbstractDatabase {
-    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.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 = nano(coudhDBSettings);
-        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);
-        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.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

@@ -1,75 +0,0 @@
-'use strict';
-
-var AbstractDatabase = require('../lib/AbstractDatabase.js');
-var Dirty = require('dirty');
-
-/**
- * 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.
- */
-/*
-*
-* Fair warning that length may not provide the correct value upon load.
-* See https://github.com/ether/etherpad-lite/pull/3984
-*
-*/
-const Database = class extends AbstractDatabase {
-    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(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

@@ -1,59 +0,0 @@
-'use strict';
-
-var AbstractDatabase = require('../lib/AbstractDatabase.js');
-var Dirty = require('dirty');
-
-const Database = class extends AbstractDatabase {
-    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.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;

package/dist/databases/elasticsearch_db.js

@@ -1,243 +0,0 @@
-'use strict';
-
-var AbstractDatabase = require('../lib/AbstractDatabase.js');
-var assert = require('assert');
-var buffer = require('buffer');
-var crypto = require('crypto');
-var elasticsearch8 = require('elasticsearch8');
-
-/**
- * 2015 Visionist, Inc.
- *
- * 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 schema = '2';
-const keyToId = (key) => {
-    const keyBuf = buffer.Buffer.from(key);
-    return keyBuf.length > 512 ? crypto.createHash('sha512').update(keyBuf).digest('hex') : key;
-};
-const mappings = {
-    // _id is expected to equal key, unless the UTF-8 encoded key is > 512 bytes, in which case it is
-    // the hex-encoded sha512 hash of the UTF-8 encoded key.
-    properties: {
-        key: { type: 'wildcard' },
-        value: { type: 'object', enabled: false }, // Values should be opaque to Elasticsearch.
-    },
-};
-const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
-    let recordsMigratedLastLogged = 0;
-    let recordsMigrated = 0;
-    const totals = new Map();
-    logger.info('Attempting elasticsearch record migration from schema v1 at base index ' +
-        `${v1BaseIndex} to schema v2 at index ${v2Index}...`);
-    const indices = await client.indices.get({ index: [v1BaseIndex, `${v1BaseIndex}-*-*`] });
-    const scrollIds = new Map();
-    const q = [];
-    try {
-        for (const index of Object.keys(indices)) {
-            const res = await client.search({ index, scroll: '10m' });
-            scrollIds.set(index, res._scroll_id);
-            q.push({ index, res });
-        }
-        while (q.length) {
-            const { index, res: { hits: { hits, total: { value: total } } } } = q.shift();
-            if (hits.length === 0)
-                continue;
-            totals.set(index, total);
-            const body = [];
-            for (const { _id, _type, _source: { val } } of hits) {
-                let key = `${_type}:${_id}`;
-                if (v1BaseIndex && index !== v1BaseIndex) {
-                    const parts = index.slice(v1BaseIndex.length + 1).split('-');
-                    if (parts.length !== 2) {
-                        throw new Error(`unable to migrate records from index ${index} due to data ambiguity`);
-                    }
-                    key = `${parts[0]}:${decodeURIComponent(_type)}:${parts[1]}:${_id}`;
-                }
-                body.push({ index: { _id: keyToId(key) } }, { key, value: JSON.parse(val) });
-            }
-            await client.bulk({ index: v2Index, body });
-            recordsMigrated += hits.length;
-            if (Math.floor(recordsMigrated / 100) > Math.floor(recordsMigratedLastLogged / 100)) {
-                const total = [...totals.values()].reduce((a, b) => a + b, 0);
-                logger.info(`Migrated ${recordsMigrated} records out of ${total}`);
-                recordsMigratedLastLogged = recordsMigrated;
-            }
-            q.push({ index, res: (await client.scroll({ scroll: '5m', scroll_id: scrollIds.get(index) })) });
-        }
-        logger.info(`Finished migrating ${recordsMigrated} records`);
-    }
-    finally {
-        await Promise.all([...scrollIds.values()].map((scrollId) => client.clearScroll({ scroll_id: scrollId })));
-    }
-};
-const Database = class extends AbstractDatabase {
-    _client;
-    _index;
-    _indexClean;
-    _q;
-    constructor(settings) {
-        super();
-        this._client = null;
-        this.settings = {
-            host: '127.0.0.1',
-            port: '9200',
-            base_index: 'ueberes',
-            migrate_to_newer_schema: false,
-            // for a list of valid API values see:
-            // https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/configuration.html#config-options
-            api: '7.6',
-            ...settings || {},
-            json: false, // Elasticsearch will do the JSON conversion as necessary.
-        };
-        this._index = `${this.settings.base_index}_s${schema}`;
-        this._q = { index: this._index };
-        this._indexClean = true;
-    }
-    get isAsync() { return true; }
-    async _refreshIndex() {
-        if (this._indexClean)
-            return;
-        this._indexClean = true;
-        await this._client.indices.refresh(this._q);
-    }
-    /**
-     * Initialize the elasticsearch client, then ping the server to ensure that a
-     * connection was made.
-     */
-    async init() {
-        // create elasticsearch client
-        const client = new elasticsearch8.Client({
-            node: `http://${this.settings.host}:${this.settings.port}`,
-        });
-        await client.ping();
-        if (!(await client.indices.exists({ index: this._index }))) {
-            let tmpIndex;
-            const exists = await client.indices.exists({ index: this.settings.base_index });
-            if (exists && !this.settings.migrate_to_newer_schema) {
-                throw new Error(`Data exists under the legacy index (schema) named ${this.settings.base_index}. ` +
-                    'Set migrate_to_newer_schema to true to copy the existing data to a new index ' +
-                    `named ${this._index}.`);
-            }
-            let attempt = 0;
-            while (true) {
-                tmpIndex = `${this._index}_${exists ? 'migrate_attempt_' : 'i'}${attempt++}`;
-                if (!(await client.indices.exists({ index: tmpIndex })))
-                    break;
-            }
-            await client.indices.create({ index: tmpIndex, mappings: mappings });
-            if (exists)
-                await migrateToSchema2(client, this.settings.base_index, tmpIndex, this.logger);
-            await client.indices.putAlias({ index: tmpIndex, name: this._index });
-        }
-        const indices = Object.values((await client.indices.get({ index: this._index })));
-        assert.equal(indices.length, 1);
-        try {
-            assert.deepEqual(indices[0].mappings, mappings);
-        }
-        catch (err) {
-            this.logger.warn(`Index ${this._index} mappings does not match expected; ` +
-                `attempting to use index anyway. Details: ${err}`);
-        }
-        this._client = client;
-    }
-    /**
-     *  This function provides read functionality to the database.
-     *
-     *  @param {String} key Key
-     */
-    async get(key) {
-        const res = await this._client.get({ ...this._q, id: keyToId(key) }, { ignore: [404] });
-        if (!res.found)
-            return null;
-        return res._source.value;
-    }
-    /**
-     *  @param key Search key, which uses an asterisk (*) as the wild card.
-     *  @param notKey Used to filter the result set
-     */
-    async findKeys(key, notKey) {
-        await this._refreshIndex();
-        const q = {
-            ...this._q,
-            body: {
-                query: {
-                    bool: {
-                        filter: { wildcard: { key: { value: key } } },
-                        ...notKey == null ? {} : {
-                            must_not: { wildcard: { key: { value: notKey } } },
-                        },
-                    },
-                },
-            },
-        };
-        const { hits: hits } = await this._client.search(q);
-        return hits.hits.map((h) => h._source.key);
-    }
-    /**
-     *  This function provides write functionality to the database.
-     *
-     *  @param {String} key Record identifier.
-     *  @param {JSON|String} value The value to store in the database.
-     */
-    async set(key, value) {
-        this._indexClean = false;
-        await this._client.index({ ...this._q, id: keyToId(key), body: { key, value } });
-    }
-    /**
-     *  This function provides delete functionality to the database.
-     *
-     *  The index, type, and ID will be parsed from the key, and this document will
-     *  be deleted from the database.
-     *
-     *  @param {String} key Record identifier.
-     */
-    async remove(key) {
-        this._indexClean = false;
-        await this._client.delete({ ...this._q, id: keyToId(key) }, { ignore: [404] });
-    }
-    /**
-     *  This uses the bulk upload functionality of elasticsearch (url:port/_bulk).
-     *
-     *  The CacheAndBufferLayer will periodically (every this.settings.writeInterval)
-     *  flush writes that have already been done in the local cache out to the database.
-     *
-     *  @param {Array} bulk An array of JSON data in the format:
-     *      {"type":type, "key":key, "value":value}
-     */
-    async doBulk(bulk) {
-        // bulk is an array of JSON:
-        // example: [{"type":"set", "key":"sessionstorage:{id}", "value":{"cookie":{...}}]
-        const operations = [];
-        for (const { type, key, value } of bulk) {
-            this._indexClean = false;
-            switch (type) {
-                case 'set':
-                    operations.push({ index: { _id: keyToId(key) } });
-                    operations.push({ key, value });
-                    break;
-                case 'remove':
-                    operations.push({ delete: { _id: keyToId(key) } });
-                    break;
-            }
-        }
-        await this._client.bulk({ ...this._q, body: operations });
-    }
-    async close() {
-        if (this._client != null)
-            this._client.close();
-        this._client = null;
-    }
-};
-
-exports.Database = Database;

package/dist/databases/memory_db.js

@@ -1,37 +0,0 @@
-'use strict';
-
-var AbstractDatabase = require('../lib/AbstractDatabase.js');
-
-const Database = class MemoryDB extends AbstractDatabase {
-    _data;
-    constructor(settings) {
-        super();
-        this.settings = settings;
-        settings.json = false;
-        settings.cache = 0;
-        settings.writeInterval = 0;
-        this._data = null;
-    }
-    get isAsync() { return true; }
-    close() {
-        this._data = null;
-    }
-    findKeys(key, notKey) {
-        const regex = this.createFindRegex(key, notKey);
-        return [...this._data.keys()].filter((k) => regex.test(k));
-    }
-    get(key) {
-        return this._data.get(key);
-    }
-    init() {
-        this._data = this.settings.data || new Map();
-    }
-    remove(key) {
-        this._data.delete(key);
-    }
-    set(key, value) {
-        this._data.set(key, value);
-    }
-};
-
-exports.Database = Database;

package/dist/databases/mock_db.js

@@ -1,41 +0,0 @@
-'use strict';
-
-var events = require('events');
-
-const Database = class extends events.EventEmitter {
-    settings;
-    mock;
-    constructor(settings) {
-        super();
-        this.settings = {
-            writeInterval: 1,
-            ...settings,
-        };
-        settings.mock = this;
-        this.settings = settings;
-        console.log("Initialized");
-    }
-    close(cb) {
-        this.emit('close', cb);
-    }
-    doBulk(ops, cb) {
-        this.emit('doBulk', ops, cb);
-    }
-    findKeys(key, notKey, cb) {
-        this.emit('findKeys', key, notKey, cb);
-    }
-    get(key, cb) {
-        this.emit('get', key, cb);
-    }
-    async init(cb) {
-        this.emit('init', cb());
-    }
-    remove(key, cb) {
-        this.emit('remove', key, cb);
-    }
-    set(key, value, cb) {
-        this.emit('set', key, value, cb);
-    }
-};
-
-exports.Database = Database;