ueberdb2 4.0.11 → 4.0.15

package/.eslintignore

@@ -0,0 +1,2 @@
+dist
+**/*.ts

package/.eslintrc.cjs

@@ -4,22 +4,61 @@
 require('eslint-config-etherpad/patch/modern-module-resolution');
 
 module.exports = {
+  parserOptions: {
+    project: ['./tsconfig.json'],
+  },
+
   root: true,
   extends: 'etherpad/node',
+
+  rules: {
+    'mocha/no-exports': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    'max-len': 'off',
+    '@typescript-eslint/restrict-template-expressions': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    'n/no-missing-import': 'off',
+    'strict': 'off',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-unsafe-argument': 'off',
+    '@typescript-eslint/no-unsafe-assignment': 'off',
+    'prefer-arrow/prefer-arrow-functions': 'off',
+    '@typescript-eslint/await-thenable': 'off',
+    '@typescript-eslint/brace-style': 'off',
+    '@typescript-eslint/comma-spacing': 'off',
+    '@typescript-eslint/consistent-type-assertions': 'off',
+    '@typescript-eslint/consistent-type-definitions': 'off',
+    '@typescript-eslint/default-param-last': 'off',
+    '@typescript-eslint/dot-notation': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-member-accessibility': 'off',
+    'func-call-spacing': 'off',
+    '@typescript-eslint/no-floating-promises': 'off',
+    'camelcase': 'off',
+    'n/no-unpublished-import': 'off',
+    'n/no-unpublished-require': 'off',
+    'no-unused-vars': 'off',
+    '@typescript-eslint/no-unused-vars': 'off',
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/restrict-plus-operands': 'off',
+  },
   overrides: [
     {
       files: [
-        'test/**/*',
+        'lib/**/*',
+        'databases/**/*',
+        'tests/**/*',
       ],
       extends: 'etherpad/tests/backend',
       overrides: [
         {
           files: [
-            'test/lib/**/*',
+            'lib/**/*',
+            'databases/**/*',
+            'tests/**/*',
           ],
-          rules: {
-            'mocha/no-exports': 'off',
-          },
+
         },
       ],
     },

package/databases/{cassandra_db.js → cassandra_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /**
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,10 +12,24 @@
  * limitations under the License.
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const cassandra = require('cassandra-driver');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+import cassandra, {ArrayOrObject, Client, types, ValueCallback} from 'cassandra-driver';
+import ResultSet = types.ResultSet;
 
-exports.Database = class extends AbstractDatabase {
+
+type Result = {
+  rows: any[];
+};
+
+export type BulkObject = {
+  type: string
+  key:string
+  value?: string
+};
+
+export const Database = class Cassandra_db extends AbstractDatabase {
+  private client: Client | undefined;
+  private pool: any;
   /**
    * @param {Object} settings The required settings object to initiate the Cassandra database
    * @param {String[]} settings.clientOptions See
@@ -28,7 +41,7 @@ exports.Database = class extends AbstractDatabase {
    *     the Cassandra driver. See https://github.com/datastax/nodejs-driver#logging for more
    *     information
    */
-  constructor(settings) {
+  constructor(settings:Settings) {
     super();
     if (!settings.clientOptions) {
       throw new Error('The Cassandra client options should be defined');
@@ -36,8 +49,7 @@ exports.Database = class extends AbstractDatabase {
     if (!settings.columnFamily) {
       throw new Error('The Cassandra column family should be defined');
     }
-
-    this.settings = {};
+    this.settings = {database: settings.database};
     this.settings.clientOptions = settings.clientOptions;
     this.settings.columnFamily = settings.columnFamily;
     this.settings.logger = settings.logger;
@@ -50,7 +62,7 @@ exports.Database = class extends AbstractDatabase {
    * @param  {Function}   callback        Standard callback method.
    * @param  {Error}      callback.err    An error object (if any.)
    */
-  init(callback) {
+  init(callback: (arg: any)=>{}) {
     // Create a client
     this.client = new cassandra.Client(this.settings.clientOptions);
 
@@ -83,7 +95,7 @@ exports.Database = class extends AbstractDatabase {
             const cql =
                 `CREATE COLUMNFAMILY "${this.settings.columnFamily}" ` +
                 '(key text PRIMARY KEY, data text)';
-            this.client.execute(cql, callback);
+            this.client && this.client.execute(cql, callback);
           }
         });
   }
@@ -96,9 +108,9 @@ exports.Database = class extends AbstractDatabase {
    * @param  {Error}      callback.err      An error object, if any
    * @param  {String}     callback.value    The value for the given key (if any)
    */
-  get(key, callback) {
+  get(key:string, callback: (err:Error | null, data?:any)=>{}) {
     const cql = `SELECT data FROM "${this.settings.columnFamily}" WHERE key = ?`;
-    this.client.execute(cql, [key], (err, result) => {
+    this.client && this.client.execute(cql, [key], (err, result) => {
       if (err) {
         return callback(err);
       }
@@ -122,12 +134,12 @@ exports.Database = class extends AbstractDatabase {
    * @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) {
+  findKeys(key:string, notKey:string, callback: Function) {
     let cql = null;
     if (!notKey) {
       // Get all the keys
       cql = `SELECT key FROM "${this.settings.columnFamily}"`;
-      this.client.execute(cql, (err, result) => {
+      this.client && this.client.execute(cql, (err: Error, result:Result) => {
         if (err) {
           return callback(err);
         }
@@ -135,7 +147,7 @@ exports.Database = class extends AbstractDatabase {
         // Construct a regular expression based on the given key
         const regex = new RegExp(`^${key.replace(/\*/g, '.*')}$`);
 
-        const keys = [];
+        const keys:string[] = [];
         result.rows.forEach((row) => {
           if (regex.test(row.key)) {
             keys.push(row.key);
@@ -151,18 +163,20 @@ exports.Database = class extends AbstractDatabase {
         // 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.execute(cql, [`ueberdb:keys:${matches[1]}`], (err, result) => {
-          if (err) {
-            return callback(err);
-          }
+        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, []);
-          }
+              if (!result.rows || result.rows.length === 0) {
+                return callback(null, []);
+              }
 
-          const keys = result.rows.map((row) => row.data);
-          return callback(null, keys);
-        });
+              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 *:*:*';
@@ -181,7 +195,7 @@ exports.Database = class extends AbstractDatabase {
    * @param  {Function}   callback        Standard callback method
    * @param  {Error}      callback.err    An error object, if any
    */
-  set(key, value, callback) {
+  set(key: string, value:string, callback:()=>{}) {
     this.doBulk([{type: 'set', key, value}], callback);
   }
 
@@ -192,10 +206,11 @@ exports.Database = class extends AbstractDatabase {
    * @param  {Function}   callback        Standard callback method
    * @param  {Error}      callback.err    An error object, if any
    */
-  remove(key, callback) {
+  remove(key:string, callback: ValueCallback<ResultSet>) {
     this.doBulk([{type: 'remove', key}], callback);
   }
 
+
   /**
    * Performs multiple operations in one action
    *
@@ -203,8 +218,8 @@ exports.Database = class extends AbstractDatabase {
    * @param  {Function}   callback        Standard callback method
    * @param  {Error}      callback.err    An error object, if any
    */
-  doBulk(bulk, callback) {
-    const queries = [];
+  doBulk(bulk:BulkObject[], callback:ValueCallback<ResultSet>) {
+    const queries:Array<string | {query: string, params?: ArrayOrObject}> = [];
     bulk.forEach((operation) => {
       // We support finding keys of the form `test:*`. If anything matches, we will try and save
       // this
@@ -235,7 +250,7 @@ exports.Database = class extends AbstractDatabase {
         }
       }
     });
-    this.client.batch(queries, {prepare: true}, callback);
+    this.client && this.client.batch(queries, {prepare: true}, callback);
   }
 
   /**
@@ -244,7 +259,7 @@ exports.Database = class extends AbstractDatabase {
    * @param  {Function}   callback        Standard callback method
    * @param  {Error}      callback.err    Error object in case something goes wrong
    */
-  close(callback) {
+  close(callback: ()=>{}) {
     this.pool.shutdown(callback);
   }
 };

package/databases/{couch_db.js → couch_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /**
  * 2012 Max 'Azul' Wiehle
  *
@@ -15,12 +14,25 @@
  * limitations under the License.
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const http = require('http');
-const nano = require('nano');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+import http, {Agent} from 'http';
+import nano from 'nano';
+import {BulkObject} from './cassandra_db';
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+type CouchDBSettings = {
+    url: string,
+    requestDefaults: {
+      auth?: {
+        username: string,
+        password: string,
+      },
+      agent: Agent
+    }
+};
+export const Database = class Couch_db extends AbstractDatabase {
+  private agent: Agent | null;
+  private db: nano.DocumentScope<string> | null;
+  constructor(settings: Settings) {
     super();
     this.agent = null;
     this.db = null;
@@ -40,38 +52,59 @@ exports.Database = class extends AbstractDatabase {
       keepAlive: true,
       maxSockets: this.settings.maxListeners || 1,
     });
-    const client = nano({
+
+    const coudhDBSettings: CouchDBSettings = {
       url: `http://${this.settings.host}:${this.settings.port}`,
       requestDefaults: {
-        auth: {
-          username: this.settings.user,
-          password: this.settings.password,
-        },
-        httpAgent: this.agent,
+        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 (this.settings.database != null) {
+        await client.db.get(this.settings.database);
+      }
+    } catch (err: any) {
       if (err.statusCode !== 404) throw err;
-      await client.db.create(this.settings.database);
+      if (this.settings.database != null) {
+        await client.db.create(this.settings.database);
+      }
+    }
+    if (this.settings.database != null) {
+      this.db = client.use(this.settings.database);
     }
-    this.db = client.use(this.settings.database);
   }
 
-  async get(key) {
+  async get(key:string): Promise<null | string> {
     let doc;
     try {
-      doc = await this.db.get(key);
-    } catch (err) {
+      if (this.db) {
+        doc = await this.db.get(key);
+      }
+    } catch (err:any) {
       if (err.statusCode === 404) return null;
       throw err;
     }
-    return doc.value;
+    if (doc && 'value' in doc) {
+      return doc.value as string;
+    }
+    return '';
   }
 
-  async findKeys(key, notKey) {
+  async findKeys(key:string, notKey:string) {
     const pfxLen = key.indexOf('*');
+    if (!this.db) {
+      return;
+    }
     const pfx = pfxLen < 0 ? key : key.slice(0, pfxLen);
     const results = await this.db.find({
       selector: {
@@ -87,15 +120,21 @@ exports.Database = class extends AbstractDatabase {
     return results.docs.map((doc) => doc._id);
   }
 
-  async set(key, value) {
+  async set(key:string, value:string) {
     let doc;
+
+    if (!this.db) {
+      return;
+    }
+
     try {
       doc = await this.db.get(key);
-    } catch (err) {
+    } catch (err:any) {
       if (err.statusCode !== 404) throw err;
     }
     await this.db.insert({
       _id: key,
+      // @ts-ignore
       value,
       ...doc == null ? {} : {
         _rev: doc._rev,
@@ -103,11 +142,14 @@ exports.Database = class extends AbstractDatabase {
     });
   }
 
-  async remove(key) {
+  async remove(key:string) {
     let header;
+    if (!this.db) {
+      return;
+    }
     try {
       header = await this.db.head(key);
-    } catch (err) {
+    } catch (err:any) {
       if (err.statusCode === 404) return;
       throw err;
     }
@@ -116,22 +158,27 @@ exports.Database = class extends AbstractDatabase {
     await this.db.destroy(key, etag);
   }
 
-  async doBulk(bulk) {
+  async doBulk(bulk:BulkObject[]) {
+    if (!this.db) {
+      return;
+    }
     const keys = bulk.map((op) => op.key);
-    const revs = {};
+    const revs:{[key:string]:any} = {};
+    // @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};
+      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 === 'set') set.value = item.value as string;
       if (item.type === 'remove') set._deleted = true;
       setters.push(set);
     }
-    await this.db.bulk({docs: setters});
+    await this.db && await this.db.bulk({docs: setters});
   }
 
   async close() {

package/databases/{dirty_db.js → dirty_db.ts}

@@ -1,4 +1,3 @@
-'use strict';
 /**
  * 2011 Peter 'Pita' Martischka
  *
@@ -22,15 +21,21 @@
 *
 */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const Dirty = require('dirty');
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+// @ts-ignore
+import Dirty from 'dirty';
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+type DirtyDBCallback = (p?:any, keys?: string[])=>{};
+
+
+export const Database = class extends AbstractDatabase {
+  private db: any;
+  constructor(settings:Settings) {
     super();
     this.db = null;
 
     if (!settings || !settings.filename) {
+      // @ts-ignore
       settings = {filename: null};
     }
 
@@ -42,21 +47,21 @@ exports.Database = class extends AbstractDatabase {
     this.settings.json = false;
   }
 
-  init(callback) {
+  init(callback: ()=>{}) {
     this.db = new Dirty(this.settings.filename);
-    this.db.on('load', (err) => {
+    this.db.on('load', (err:string) => {
       callback();
     });
   }
 
-  get(key, callback) {
+  get(key:string, callback:DirtyDBCallback) {
     callback(null, this.db.get(key));
   }
 
-  findKeys(key, notKey, callback) {
-    const keys = [];
+  findKeys(key:string, notKey:string, callback:DirtyDBCallback) {
+    const keys:string[] = [];
     const regex = this.createFindRegex(key, notKey);
-    this.db.forEach((key, val) => {
+    this.db.forEach((key:string, val:string) => {
       if (key.search(regex) !== -1) {
         keys.push(key);
       }
@@ -64,15 +69,15 @@ exports.Database = class extends AbstractDatabase {
     callback(null, keys);
   }
 
-  set(key, value, callback) {
+  set(key:string, value:string, callback:DirtyDBCallback) {
     this.db.set(key, value, callback);
   }
 
-  remove(key, callback) {
+  remove(key:string, callback:DirtyDBCallback) {
     this.db.rm(key, callback);
   }
 
-  close(callback) {
+  close(callback:DirtyDBCallback) {
     this.db.close();
     this.db = null;
     if (callback) callback();

package/databases/{dirty_git_db.js → dirty_git_db.ts}

@@ -1,4 +1,5 @@
-'use strict';
+import AbstractDatabase, {Settings} from '../lib/AbstractDatabase';
+
 /**
  * 2011 Peter 'Pita' Martischka
  *
@@ -15,16 +16,19 @@
  * limitations under the License.
  */
 
-const AbstractDatabase = require('../lib/AbstractDatabase');
-const Dirty = require('dirty');
 
-exports.Database = class extends AbstractDatabase {
-  constructor(settings) {
+// @ts-ignore
+import {Dirty} from 'dirty';
+
+export const Database = class extends AbstractDatabase {
+  private db: any;
+  constructor(settings: Settings) {
     super();
+    // @ts-ignore
     this.db = null;
 
     if (!settings || !settings.filename) {
-      settings = {filename: null};
+      settings = {};
     }
 
     this.settings = settings;
@@ -35,21 +39,21 @@ exports.Database = class extends AbstractDatabase {
     this.settings.json = false;
   }
 
-  init(callback) {
+  init(callback: ()=>void) {
     this.db = new Dirty(this.settings.filename);
-    this.db.on('load', (err) => {
+    this.db.on('load', (err: Error) => {
       callback();
     });
   }
 
-  get(key, callback) {
+  get(key:string, callback: (err: string | any, value: string)=>void) {
     callback(null, this.db.get(key));
   }
 
-  findKeys(key, notKey, callback) {
-    const keys = [];
+  findKeys(key:string, notKey:string, callback:(v:any, keys:string[])=>{}) {
+    const keys:string[] = [];
     const regex = this.createFindRegex(key, notKey);
-    this.db.forEach((key, val) => {
+    this.db.forEach((key:string, val:string) => {
       if (key.search(regex) !== -1) {
         keys.push(key);
       }
@@ -57,7 +61,7 @@ exports.Database = class extends AbstractDatabase {
     callback(null, keys);
   }
 
-  set(key, value, callback) {
+  set(key:string, value: string, callback: ()=>{}) {
     this.db.set(key, value, callback);
     const databasePath = require('path').dirname(this.settings.filename);
     require('simple-git')(databasePath)
@@ -67,11 +71,11 @@ exports.Database = class extends AbstractDatabase {
         .push(['-u', 'origin', 'master'], () => console.debug('Stored git commit'));
   }
 
-  remove(key, callback) {
+  remove(key:string, callback:()=> {}) {
     this.db.rm(key, callback);
   }
 
-  close(callback) {
+  close(callback: ()=>void) {
     this.db.close();
     if (callback) callback();
   }