mongodb-livedata-server 0.0.1

package/meteor/ordered-dict/ordered_dict.ts

@@ -0,0 +1,229 @@
+// This file defines an ordered dictionary abstraction that is useful for
+// maintaining a dataset backed by observeChanges.  It supports ordering items
+// by specifying the item they now come before.
+
+// The implementation is a dictionary that contains nodes of a doubly-linked
+// list as its values.
+
+// constructs a new element struct
+// next and prev are whole elements, not keys.
+function element(key, value, next, prev?) {
+    return {
+        key: key,
+        value: value,
+        next: next,
+        prev: prev
+    };
+}
+
+export class OrderedDict {
+    public static BREAK = { "break": true };
+
+    private _dict: Record<string, any>;
+    private _first: any;
+    private _last: any;
+    private _size: number;
+    private _stringify: Function;
+
+    constructor(...args) {
+        this._dict = Object.create(null);
+        this._first = null;
+        this._last = null;
+        this._size = 0;
+
+        if (typeof args[0] === 'function') {
+            this._stringify = args.shift();
+        } else {
+            this._stringify = function (x) { return x; };
+        }
+
+        args.forEach(kv => this.putBefore(kv[0], kv[1], null));
+    }
+
+    // the "prefix keys with a space" thing comes from here
+    // https://github.com/documentcloud/underscore/issues/376#issuecomment-2815649
+    _k(key: any) {
+        return " " + this._stringify(key);
+    }
+
+    empty() {
+        return !this._first;
+    }
+
+    size() {
+        return this._size;
+    }
+
+    _linkEltIn(elt) {
+        if (!elt.next) {
+            elt.prev = this._last;
+            if (this._last)
+                this._last.next = elt;
+            this._last = elt;
+        } else {
+            elt.prev = elt.next.prev;
+            elt.next.prev = elt;
+            if (elt.prev)
+                elt.prev.next = elt;
+        }
+        if (this._first === null || this._first === elt.next)
+            this._first = elt;
+    }
+
+    _linkEltOut(elt) {
+        if (elt.next)
+            elt.next.prev = elt.prev;
+        if (elt.prev)
+            elt.prev.next = elt.next;
+        if (elt === this._last)
+            this._last = elt.prev;
+        if (elt === this._first)
+            this._first = elt.next;
+    }
+
+    putBefore(key, item, before) {
+        if (this._dict[this._k(key)])
+            throw new Error("Item " + key + " already present in OrderedDict");
+        var elt = before ?
+            element(key, item, this._dict[this._k(before)]) :
+            element(key, item, null);
+        if (typeof elt.next === "undefined")
+            throw new Error("could not find item to put this one before");
+        this._linkEltIn(elt);
+        this._dict[this._k(key)] = elt;
+        this._size++;
+    }
+
+    append(key, item) {
+        this.putBefore(key, item, null);
+    }
+
+    remove(key) {
+        var elt = this._dict[this._k(key)];
+        if (typeof elt === "undefined")
+            throw new Error("Item " + key + " not present in OrderedDict");
+        this._linkEltOut(elt);
+        this._size--;
+        delete this._dict[this._k(key)];
+        return elt.value;
+    }
+
+    get(key) {
+        if (this.has(key)) {
+            return this._dict[this._k(key)].value;
+        }
+    }
+
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(
+            this._dict,
+            this._k(key)
+        );
+    }
+
+    // Iterate through the items in this dictionary in order, calling
+    // iter(value, key, index) on each one.
+
+    // Stops whenever iter returns OrderedDict.BREAK, or after the last element.
+    forEach(iter, context = null) {
+        var i = 0;
+        var elt = this._first;
+        while (elt !== null) {
+            var b = iter.call(context, elt.value, elt.key, i);
+            if (b === OrderedDict.BREAK) return;
+            elt = elt.next;
+            i++;
+        }
+    }
+
+    first() {
+        if (this.empty()) {
+            return;
+        }
+        return this._first.key;
+    }
+
+    firstValue() {
+        if (this.empty()) {
+            return;
+        }
+        return this._first.value;
+    }
+
+    last() {
+        if (this.empty()) {
+            return;
+        }
+        return this._last.key;
+    }
+
+    lastValue() {
+        if (this.empty()) {
+            return;
+        }
+        return this._last.value;
+    }
+
+    prev(key) {
+        if (this.has(key)) {
+            var elt = this._dict[this._k(key)];
+            if (elt.prev)
+                return elt.prev.key;
+        }
+        return null;
+    }
+
+    next(key) {
+        if (this.has(key)) {
+            var elt = this._dict[this._k(key)];
+            if (elt.next)
+                return elt.next.key;
+        }
+        return null;
+    }
+
+    moveBefore(key, before) {
+        var elt = this._dict[this._k(key)];
+        var eltBefore = before ? this._dict[this._k(before)] : null;
+        if (typeof elt === "undefined") {
+            throw new Error("Item to move is not present");
+        }
+        if (typeof eltBefore === "undefined") {
+            throw new Error("Could not find element to move this one before");
+        }
+        if (eltBefore === elt.next) // no moving necessary
+            return;
+        // remove from its old place
+        this._linkEltOut(elt);
+        // patch into its new place
+        elt.next = eltBefore;
+        this._linkEltIn(elt);
+    }
+
+    // Linear, sadly.
+    indexOf(key) {
+        var ret = null;
+        this.forEach((v, k, i) => {
+            if (this._k(k) === this._k(key)) {
+                ret = i;
+                return OrderedDict.BREAK;
+            }
+            return;
+        });
+        return ret;
+    }
+
+    _checkRep() {
+        Object.keys(this._dict).forEach(k => {
+            const v = this._dict[k];
+            if (v.next === v) {
+                throw new Error("Next is a loop");
+            }
+            if (v.prev === v) {
+                throw new Error("Prev is a loop");
+            }
+        });
+    }
+    
+}
+

package/meteor/random/AbstractRandomGenerator.ts

@@ -0,0 +1,99 @@
+// We use cryptographically strong PRNGs (crypto.getRandomBytes() on the server,
+// window.crypto.getRandomValues() in the browser) when available. If these
+// PRNGs fail, we fall back to the Alea PRNG, which is not cryptographically
+// strong, and we seed it with various sources such as the date, Math.random,
+// and window size on the client.  When using crypto.getRandomValues(), our
+// primitive is hexString(), from which we construct fraction(). When using
+// window.crypto.getRandomValues() or alea, the primitive is fraction and we use
+// that to construct hex string.
+
+const UNMISTAKABLE_CHARS = '23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE64_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+  '0123456789-_';
+
+// `type` is one of `RandomGenerator.Type` as defined below.
+//
+// options:
+// - seeds: (required, only for RandomGenerator.Type.ALEA) an array
+//   whose items will be `toString`ed and used as the seed to the Alea
+//   algorithm
+export default class RandomGenerator {
+
+  /**
+   * @name Random.fraction
+   * @summary Return a number between 0 and 1, like `Math.random`.
+   * @locus Anywhere
+   */
+  fraction (): number {
+    throw new Error(`Unknown random generator type`);
+  }
+
+  /**
+   * @name Random.hexString
+   * @summary Return a random string of `n` hexadecimal digits.
+   * @locus Anywhere
+   * @param {Number} n Length of the string
+   */
+  hexString (digits) {
+    return this._randomString(digits, '0123456789abcdef');
+  }
+
+  _randomString (charsCount, alphabet) {
+    let result = '';
+    for (let i = 0; i < charsCount; i++) {	
+      result += this.choice(alphabet);
+    }
+    return result;
+  }
+
+  /**
+   * @name Random.id
+   * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
+   * likely to be unique in the whole world.
+   * @locus Anywhere
+   * @param {Number} [n] Optional length of the identifier in characters
+   *   (defaults to 17)
+   */
+  id (charsCount) {
+    // 17 characters is around 96 bits of entropy, which is the amount of
+    // state in the Alea PRNG.
+    if (charsCount === undefined) {
+      charsCount = 17;
+    }
+
+    return this._randomString(charsCount, UNMISTAKABLE_CHARS);
+  }
+
+  /**
+   * @name Random.secret
+   * @summary Return a random string of printable characters with 6 bits of
+   * entropy per character. Use `Random.secret` for security-critical secrets
+   * that are intended for machine, rather than human, consumption.
+   * @locus Anywhere
+   * @param {Number} [n] Optional length of the secret string (defaults to 43
+   *   characters, or 256 bits of entropy)
+   */
+  secret (charsCount) {
+    // Default to 256 bits of entropy, or 43 characters at 6 bits per
+    // character.
+    if (charsCount === undefined) {
+      charsCount = 43;
+    }
+
+    return this._randomString(charsCount, BASE64_CHARS);
+  }
+
+  /**
+   * @name Random.choice
+   * @summary Return a random element of the given array or string.
+   * @locus Anywhere
+   * @param {Array|String} arrayOrString Array or string to choose from
+   */
+  choice (arrayOrString) {
+    const index = Math.floor(this.fraction() * arrayOrString.length);
+    if (typeof arrayOrString === 'string') {
+      return arrayOrString.substr(index, 1);
+    }
+    return arrayOrString[index];
+  }
+}

package/meteor/random/AleaRandomGenerator.ts

@@ -0,0 +1,96 @@
+import RandomGenerator from './AbstractRandomGenerator';
+
+// Alea PRNG, which is not cryptographically strong
+// see http://baagoe.org/en/wiki/Better_random_numbers_for_javascript
+// for a full discussion and Alea implementation.
+function Alea(seeds) {
+  function Mash() {
+    let n = 0xefc8249d;
+
+    const mash = (data) => {
+      data = data.toString();
+      for (let i = 0; i < data.length; i++) {
+        n += data.charCodeAt(i);
+        let h = 0.02519603282416938 * n;
+        n = h >>> 0;
+        h -= n;
+        h *= n;
+        n = h >>> 0;
+        h -= n;
+        n += h * 0x100000000; // 2^32
+      }
+      return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+    };
+
+    mash.version = 'Mash 0.9';
+    return mash;
+  }
+
+  let s0 = 0;
+  let s1 = 0;
+  let s2 = 0;
+  let c = 1;
+  if (seeds.length === 0) {
+    seeds = [+new Date];
+  }
+  let mash = Mash();
+  s0 = mash(' ');
+  s1 = mash(' ');
+  s2 = mash(' ');
+
+  for (let i = 0; i < seeds.length; i++) {
+    s0 -= mash(seeds[i]);
+    if (s0 < 0) {
+      s0 += 1;
+    }
+    s1 -= mash(seeds[i]);
+    if (s1 < 0) {
+      s1 += 1;
+    }
+    s2 -= mash(seeds[i]);
+    if (s2 < 0) {
+      s2 += 1;
+    }
+  }
+  mash = null;
+
+  const random = () => {
+    const t = (2091639 * s0) + (c * 2.3283064365386963e-10); // 2^-32
+    s0 = s1;
+    s1 = s2;
+    return s2 = t - (c = t | 0);
+  };
+
+  random.uint32 = () => random() * 0x100000000; // 2^32
+  random.fract53 = () => random() +
+        ((random() * 0x200000 | 0) * 1.1102230246251565e-16); // 2^-53
+
+  random.version = 'Alea 0.9';
+  random.args = seeds;
+  return random;
+}
+
+// options:
+// - seeds: an array
+//   whose items will be `toString`ed and used as the seed to the Alea
+//   algorithm
+export default class AleaRandomGenerator extends RandomGenerator {
+  private alea: ReturnType<typeof Alea>;
+
+  constructor ({ seeds = [] } = {}) {
+    super();
+    if (!seeds) {
+      throw new Error('No seeds were provided for Alea PRNG');
+    }
+    this.alea = Alea(seeds);
+  }
+
+  /**
+   * @name Random.fraction
+   * @summary Return a number between 0 and 1, like `Math.random`.
+   * @locus Anywhere
+   */
+  fraction () {
+    return this.alea();
+  }
+}

package/meteor/random/NodeRandomGenerator.ts

@@ -0,0 +1,37 @@
+import crypto from 'crypto';
+import RandomGenerator from './AbstractRandomGenerator';
+
+export default class NodeRandomGenerator extends RandomGenerator {
+  /**
+   * @name Random.fraction
+   * @summary Return a number between 0 and 1, like `Math.random`.
+   * @locus Anywhere
+   */
+  fraction () {
+    const numerator = Number.parseInt(this.hexString(8), 16);
+    return numerator * 2.3283064365386963e-10; // 2^-3;
+  }
+
+  /**
+   * @name Random.hexString
+   * @summary Return a random string of `n` hexadecimal digits.
+   * @locus Anywhere
+   * @param {Number} n Length of the string
+   */
+  hexString (digits) {
+    const numBytes = Math.ceil(digits / 2);
+    let bytes;
+    // Try to get cryptographically strong randomness. Fall back to
+    // non-cryptographically strong if not available.
+    try {
+      bytes = crypto.randomBytes(numBytes);
+    } catch (e) {
+      // XXX should re-throw any error except insufficient entropy
+      bytes = crypto.pseudoRandomBytes(numBytes);
+    }
+    const result = bytes.toString('hex');
+    // If the number of digits is odd, we'll have generated an extra 4 bits
+    // of randomness, so we need to trim the last digit.
+    return result.substring(0, digits);
+  }
+}

package/meteor/random/createAleaGenerator.ts

@@ -0,0 +1,31 @@
+import AleaRandomGenerator from './AleaRandomGenerator';
+
+// instantiate RNG.  Heuristically collect entropy from various sources when a
+// cryptographic PRNG isn't available.
+
+// client sources
+const height = (typeof window !== 'undefined' && window.innerHeight) ||
+      (typeof document !== 'undefined'
+       && document.documentElement
+       && document.documentElement.clientHeight) ||
+      (typeof document !== 'undefined'
+       && document.body
+       && document.body.clientHeight) ||
+      1;
+
+const width = (typeof window !== 'undefined' && window.innerWidth) ||
+      (typeof document !== 'undefined'
+       && document.documentElement
+       && document.documentElement.clientWidth) ||
+      (typeof document !== 'undefined'
+       && document.body
+       && document.body.clientWidth) ||
+      1;
+
+const agent = (typeof navigator !== 'undefined' && navigator.userAgent) || '';
+
+export default function createAleaGenerator() {
+  return new AleaRandomGenerator({
+    seeds: [new Date, height, width, agent, Math.random()],
+  });
+}

package/meteor/random/createRandom.ts

@@ -0,0 +1,19 @@
+import AleaRandomGenerator from './AleaRandomGenerator'
+import createAleaGeneratorWithGeneratedSeed from './createAleaGenerator';
+
+export default function createRandom(generator) {
+  // Create a non-cryptographically secure PRNG with a given seed (using
+  // the Alea algorithm)
+  generator.createWithSeeds = (...seeds) => {
+    if (seeds.length === 0) {
+      throw new Error('No seeds were provided');
+    }
+    return new AleaRandomGenerator({ seeds });
+  };
+
+  // Used like `Random`, but much faster and not cryptographically
+  // secure
+  generator.insecure = createAleaGeneratorWithGeneratedSeed();
+
+  return generator;
+}

package/meteor/random/main.ts

@@ -0,0 +1,8 @@
+// We use cryptographically strong PRNGs (crypto.getRandomBytes())
+// When using crypto.getRandomValues(), our primitive is hexString(),
+// from which we construct fraction().
+
+import NodeRandomGenerator from './NodeRandomGenerator';
+import createRandom from './createRandom';
+
+export const Random = createRandom(new NodeRandomGenerator());

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "mongodb-livedata-server",
+  "version": "0.0.1",
+  "description": "MongoDB live data server, extracted from Meteor, Fibers removed and converted to TypeScript",
+  "main": "dist/livedata_server.js",
+  "types": "livedata_server.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Andrei Markeev",
+  "license": "MIT",
+  "dependencies": {
+    "compression": "^1.7.4",
+    "connect": "^3.7.0",
+    "cookie-parser": "^1.4.6",
+    "double-ended-queue": "^2.1.0-0",
+    "mongodb": "^4.11.0",
+    "permessage-deflate": "^0.1.7",
+    "send": "^0.18.0",
+    "sockjs": "^0.3.24",
+    "useragent": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/connect": "^3.4.35",
+    "@types/double-ended-queue": "^2.1.1",
+    "@types/node": "^18.11.9",
+    "@types/sockjs": "^0.3.33"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "compilerOptions": {
+        "target": "ES2017",
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "outDir": "dist",
+        "rootDir": "."
+    }
+}