mongodb-livedata-server 0.0.4 → 0.0.6

package/meteor/ejson/stringify.ts

@@ -1,122 +0,0 @@
-// Based on json2.js from https://github.com/douglascrockford/JSON-js
-//
-//    json2.js
-//    2012-10-08
-//
-//    Public Domain.
-//
-//    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
-
-function quote(string) {
-    return JSON.stringify(string);
-  }
-  
-  const str = (key, holder, singleIndent, outerIndent, canonical): string => {
-    const value = holder[key];
-  
-    // What happens next depends on the value's type.
-    switch (typeof value) {
-    case 'string':
-      return quote(value);
-    case 'number':
-      // JSON numbers must be finite. Encode non-finite numbers as null.
-      return isFinite(value) ? String(value) : 'null';
-    case 'boolean':
-      return String(value);
-    // If the type is 'object', we might be dealing with an object or an array or
-    // null.
-    case 'object': {
-      // Due to a specification blunder in ECMAScript, typeof null is 'object',
-      // so watch out for that case.
-      if (!value) {
-        return 'null';
-      }
-      // Make an array to hold the partial results of stringifying this object
-      // value.
-      const innerIndent = outerIndent + singleIndent;
-      const partial = [];
-      let v;
-  
-      // Is the value an array?
-      if (Array.isArray(value) || ({}).hasOwnProperty.call(value, 'callee')) {
-        // The value is an array. Stringify every element. Use null as a
-        // placeholder for non-JSON values.
-        const length = value.length;
-        for (let i = 0; i < length; i += 1) {
-          partial[i] =
-            str(i, value, singleIndent, innerIndent, canonical) || 'null';
-        }
-  
-        // Join all of the elements together, separated with commas, and wrap
-        // them in brackets.
-        if (partial.length === 0) {
-          v = '[]';
-        } else if (innerIndent) {
-          v = '[\n' +
-            innerIndent +
-            partial.join(',\n' +
-            innerIndent) +
-            '\n' +
-            outerIndent +
-            ']';
-        } else {
-          v = '[' + partial.join(',') + ']';
-        }
-        return v;
-      }
-  
-      // Iterate through all of the keys in the object.
-      let keys = Object.keys(value);
-      if (canonical) {
-        keys = keys.sort();
-      }
-      keys.forEach(k => {
-        v = str(k, value, singleIndent, innerIndent, canonical);
-        if (v) {
-          partial.push(quote(k) + (innerIndent ? ': ' : ':') + v);
-        }
-      });
-  
-      // Join all of the member texts together, separated with commas,
-      // and wrap them in braces.
-      if (partial.length === 0) {
-        v = '{}';
-      } else if (innerIndent) {
-        v = '{\n' +
-          innerIndent +
-          partial.join(',\n' +
-          innerIndent) +
-          '\n' +
-          outerIndent +
-          '}';
-      } else {
-        v = '{' + partial.join(',') + '}';
-      }
-      return v;
-    }
-  
-    default: // Do nothing
-    }
-  };
-  
-  // If the JSON object does not yet have a stringify method, give it one.
-  const canonicalStringify = (value, options) => {
-    // Make a fake root object containing our value under the key of ''.
-    // Return the result of stringifying the value.
-    const allOptions = Object.assign({
-      indent: '',
-      canonical: false,
-    }, options);
-    if (allOptions.indent === true) {
-      allOptions.indent = '  ';
-    } else if (typeof allOptions.indent === 'number') {
-      let newIndent = '';
-      for (let i = 0; i < allOptions.indent; i++) {
-        newIndent += ' ';
-      }
-      allOptions.indent = newIndent;
-    }
-    return str('', {'': value}, allOptions.indent, '', allOptions.canonical);
-  };
-  
-  export default canonicalStringify;

package/meteor/ejson/utils.ts

@@ -1,38 +0,0 @@
-export const isFunction = (fn) => typeof fn === 'function';
-
-export const isObject = (fn) => typeof fn === 'object';
-
-export const keysOf = (obj) => Object.keys(obj);
-
-export const lengthOf = (obj) => Object.keys(obj).length;
-
-export const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-
-export const convertMapToObject = (map) => Array.from(map).reduce((acc, [key, value]) => {
-  // reassign to not create new object
-  acc[key] = value;
-  return acc;
-}, {});
-
-export function isArguments (obj: any): obj is ArrayLike<any> {
-    return obj != null && hasOwn(obj, 'callee');
-}
-
-export const isInfOrNaN =
-  obj => Number.isNaN(obj) || obj === Infinity || obj === -Infinity;
-
-export const checkError = {
-  maxStack: (msgError) => new RegExp('Maximum call stack size exceeded', 'g').test(msgError),
-};
-
-export function handleError<F extends (...args: any[]) => any>(fn: F, ...args: any[]) {
-  try {
-    return fn.apply(this, args) as ReturnType<F>;
-  } catch (error) {
-    const isMaxStack = checkError.maxStack(error.message);
-    if (isMaxStack) {
-      throw new Error('Converting circular structure to JSON')
-    }
-    throw error;
-  }
-};

package/meteor/id-map/id_map.ts

@@ -1,84 +0,0 @@
-import * as EJSON from "../ejson/ejson";
-
-export class IdMap {
-    private _map: Map<string, any>;
-    private _idStringify: (obj: any) => string;
-    private _idParse: (str: string) => any;
-    constructor(idStringify?: (obj: any) => string, idParse?: (str: string) => any) {
-        this._map = new Map();
-        this._idStringify = idStringify || JSON.stringify;
-        this._idParse = idParse || JSON.parse;
-    }
-
-    // Some of these methods are designed to match methods on OrderedDict, since
-    // (eg) ObserveMultiplex and _CachingChangeObserver use them interchangeably.
-    // (Conceivably, this should be replaced with "UnorderedDict" with a specific
-    // set of methods that overlap between the two.)
-
-    get(id) {
-        const key = this._idStringify(id);
-        return this._map.get(key);
-    }
-
-    set(id, value) {
-        const key = this._idStringify(id);
-        this._map.set(key, value);
-    }
-
-    remove(id) {
-        const key = this._idStringify(id);
-        this._map.delete(key);
-    }
-
-    has(id) {
-        const key = this._idStringify(id);
-        return this._map.has(key);
-    }
-
-    empty() {
-        return this._map.size === 0;
-    }
-
-    clear() {
-        this._map.clear();
-    }
-
-    // Iterates over the items in the map. Return `false` to break the loop.
-    forEach(iterator) {
-        // don't use _.each, because we can't break out of it.
-        for (let [key, value] of this._map) {
-            const breakIfFalse = iterator.call(
-                null,
-                value,
-                this._idParse(key)
-            );
-            if (breakIfFalse === false) {
-                return;
-            }
-        }
-    }
-
-    size() {
-        return this._map.size;
-    }
-
-    setDefault(id, def) {
-        const key = this._idStringify(id);
-        if (this._map.has(key)) {
-            return this._map.get(key);
-        }
-        this._map.set(key, def);
-        return def;
-    }
-
-    // Assumes that values are EJSON-cloneable, and that we don't need to clone
-    // IDs (ie, that nobody is going to mutate an ObjectId).
-    clone() {
-        const clone = new IdMap(this._idStringify, this._idParse);
-        // copy directly to avoid stringify/parse overhead
-        this._map.forEach(function (value, key) {
-            clone._map.set(key, EJSON.clone(value));
-        });
-        return clone;
-    }
-}

package/meteor/mongo/caching_change_observer.ts

@@ -1,120 +0,0 @@
-// _CachingChangeObserver is an object which receives observeChanges callbacks
-// and keeps a cache of the current cursor state up to date in this.docs. Users
-// of this class should read the docs field but not modify it. You should pass
-// the "applyChange" field as the callbacks to the underlying observeChanges
-// call. Optionally, you can specify your own observeChanges callbacks which are
-// invoked immediately before the docs field is updated; this object is made
-
-import { DiffSequence } from "../diff-sequence/diff";
-import { clone } from "../ejson/ejson";
-import { OrderedDict } from "../ordered-dict/ordered_dict";
-
-// available as `this` to those callbacks.
-export class _CachingChangeObserver {
-    public docs: OrderedDict | Map<string, any>;
-    public applyChange: {
-        added?: (id: string, fields: any) => void;
-        changed?: (id: string, fields: any) => void;
-        removed?: (id: string) => void;
-        addedBefore?: (id: string, fields: any, before: any) => void;
-        movedBefore?: (id: string, before: any) => void;
-    };
-
-    private ordered: boolean;
-
-    constructor(options: { callbacks?: any, ordered?: boolean } = {}) {
-      const orderedFromCallbacks = (
-        options.callbacks &&
-        !!(options.callbacks.addedBefore || options.callbacks.movedBefore)
-      );
-  
-      if (options.hasOwnProperty('ordered')) {
-        this.ordered = options.ordered;
-  
-        if (options.callbacks && options.ordered !== orderedFromCallbacks) {
-          throw Error('ordered option doesn\'t match callbacks');
-        }
-      } else if (options.callbacks) {
-        this.ordered = orderedFromCallbacks;
-      } else {
-        throw Error('must provide ordered or callbacks');
-      }
-  
-      const callbacks = options.callbacks || {};
-  
-      if (this.ordered) {
-        this.docs = new OrderedDict();
-        this.applyChange = {
-          addedBefore: (id, fields, before) => {
-            // Take a shallow copy since the top-level properties can be changed
-            const doc = { ...fields };
-  
-            doc._id = id;
-  
-            if (callbacks.addedBefore) {
-              callbacks.addedBefore.call(this, id, clone(fields), before);
-            }
-  
-            // This line triggers if we provide added with movedBefore.
-            if (callbacks.added) {
-              callbacks.added.call(this, id, clone(fields));
-            }
-  
-            // XXX could `before` be a falsy ID?  Technically
-            // idStringify seems to allow for them -- though
-            // OrderedDict won't call stringify on a falsy arg.
-            (this.docs as OrderedDict).putBefore(id, doc, before || null);
-          },
-          movedBefore: (id, before) => {
-            const doc = this.docs.get(id);
-  
-            if (callbacks.movedBefore) {
-              callbacks.movedBefore.call(this, id, before);
-            }
-  
-            (this.docs as OrderedDict).moveBefore(id, before || null);
-          },
-        };
-      } else {
-        this.docs = new Map();
-        this.applyChange = {
-          added: (id, fields) => {
-            // Take a shallow copy since the top-level properties can be changed
-            const doc = { ...fields };
-  
-            if (callbacks.added) {
-              callbacks.added.call(this, id, clone(fields));
-            }
-  
-            doc._id = id;
-  
-            (this.docs as Map<string, any>).set(id,  doc);
-          },
-        };
-      }
-  
-      // The methods in _IdMap and OrderedDict used by these callbacks are
-      // identical.
-      this.applyChange.changed = (id, fields) => {
-        const doc = this.docs.get(id);
-  
-        if (!doc) {
-          throw new Error(`Unknown id for changed: ${id}`);
-        }
-  
-        if (callbacks.changed) {
-          callbacks.changed.call(this, id, clone(fields));
-        }
-  
-        DiffSequence.applyChanges(doc, fields);
-      };
-  
-      this.applyChange.removed = id => {
-        if (callbacks.removed) {
-          callbacks.removed.call(this, id);
-        }
-  
-        (this.docs as Map<string, any>).delete(id);
-      };
-    }
-  };

package/meteor/mongo/doc_fetcher.ts

@@ -1,52 +0,0 @@
-import MongoDB from "mongodb";
-import { clone } from "../ejson/ejson";
-
-export class DocFetcher {
-    private _callbacksForOp = new Map<Object, Function[]>();
-    constructor(private db: MongoDB.Db) {
-    }
-
-    // Fetches document "id" from collectionName, returning it or null if not
-    // found.
-    //
-    // If you make multiple calls to fetch() with the same op reference,
-    // DocFetcher may assume that they all return the same document. (It does
-    // not check to see if collectionName/id match.)
-    //
-    // You may assume that callback is never called synchronously (and in fact
-    // OplogObserveDriver does so).
-    async fetch(collectionName: string, id: string, op: Object, callback: Function) {
-        const self = this;
-
-        // If there's already an in-progress fetch for this cache key, yield until
-        // it's done and return whatever it returns.
-        if (self._callbacksForOp.has(op)) {
-            self._callbacksForOp.get(op).push(callback);
-            return;
-        }
-
-        const callbacks = [callback];
-        self._callbacksForOp.set(op, callbacks);
-
-        try {
-            var doc = await self.db.collection(collectionName).findOne({ _id: id }) || null;
-            // Return doc to all relevant callbacks. Note that this array can
-            // continue to grow during callback execution.
-            while (callbacks.length > 0) {
-                // Clone the document so that the various calls to fetch don't return
-                // objects that are intertwingled with each other. Clone before
-                // popping the future, so that if clone throws, the error gets passed
-                // to the next callback.
-                callbacks.pop()(null, clone(doc));
-            }
-        } catch (e) {
-            while (callbacks.length > 0) {
-                callbacks.pop()(e);
-            }
-        } finally {
-            // XXX consider keeping the doc around for a period of time before
-            // removing from the cache
-            self._callbacksForOp.delete(op);
-        }
-    }
-}

package/meteor/mongo/geojson_utils.ts

@@ -1,42 +0,0 @@
-export function numberToRadius(number) {
-    return number * Math.PI / 180;
-}
-
-// from http://www.movable-type.co.uk/scripts/latlong.html
-export function pointDistance(pt1, pt2) {
-    var lon1 = pt1.coordinates[0],
-        lat1 = pt1.coordinates[1],
-        lon2 = pt2.coordinates[0],
-        lat2 = pt2.coordinates[1],
-        dLat = numberToRadius(lat2 - lat1),
-        dLon = numberToRadius(lon2 - lon1),
-        a = Math.pow(Math.sin(dLat / 2), 2) + Math.cos(numberToRadius(lat1))
-            * Math.cos(numberToRadius(lat2)) * Math.pow(Math.sin(dLon / 2), 2),
-        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    // Earth radius is 6371 km
-    return (6371 * c) * 1000; // returns meters
-}
-
-// checks if geometry lies entirely within a circle
-// works with Point, LineString, Polygon
-export function geometryWithinRadius(geometry, center, radius) {
-    if (geometry.type == 'Point') {
-        return pointDistance(geometry, center) <= radius;
-    } else if (geometry.type == 'LineString' || geometry.type == 'Polygon') {
-        var point: any = {};
-        var coordinates;
-        if (geometry.type == 'Polygon') {
-            // it's enough to check the exterior ring of the Polygon
-            coordinates = geometry.coordinates[0];
-        } else {
-            coordinates = geometry.coordinates;
-        }
-        for (var i in coordinates) {
-            point.coordinates = coordinates[i];
-            if (pointDistance(point, center) > radius) {
-                return false;
-            }
-        }
-    }
-    return true;
-}