mongodb-livedata-server 0.0.1

package/meteor/ddp/utils.ts

@@ -0,0 +1,119 @@
+"use strict";
+
+import { clone, _adjustTypesFromJSONValue, _adjustTypesToJSONValue } from "../ejson/ejson";
+
+export const hasOwn = Object.prototype.hasOwnProperty;
+export const slice = Array.prototype.slice;
+
+export function keys(obj) {
+  return Object.keys(Object(obj));
+}
+
+export function isEmpty(obj) {
+  if (obj == null) {
+    return true;
+  }
+
+  if (Array.isArray(obj) ||
+      typeof obj === "string") {
+    return obj.length === 0;
+  }
+
+  for (const key in obj) {
+    if (hasOwn.call(obj, key)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function last(array, n, guard) {
+  if (array == null) {
+    return;
+  }
+
+  if ((n == null) || guard) {
+    return array[array.length - 1];
+  }
+
+  return slice.call(array, Math.max(array.length - n, 0));
+}
+
+export const SUPPORTED_DDP_VERSIONS = [ '1', 'pre2', 'pre1' ];
+
+export function parseDDP(stringMessage: string) {
+  try {
+    var msg = JSON.parse(stringMessage);
+  } catch (e) {
+    console.log("Discarding message with invalid JSON", stringMessage);
+    return null;
+  }
+  // DDP messages must be objects.
+  if (msg === null || typeof msg !== 'object') {
+    console.log("Discarding non-object DDP message", stringMessage);
+    return null;
+  }
+
+  // massage msg to get it into "abstract ddp" rather than "wire ddp" format.
+
+  // switch between "cleared" rep of unsetting fields and "undefined"
+  // rep of same
+  if (hasOwn.call(msg, 'cleared')) {
+    if (! hasOwn.call(msg, 'fields')) {
+      msg.fields = {};
+    }
+    msg.cleared.forEach(clearKey => {
+      msg.fields[clearKey] = undefined;
+    });
+    delete msg.cleared;
+  }
+
+  ['fields', 'params', 'result'].forEach(field => {
+    if (hasOwn.call(msg, field)) {
+      msg[field] = _adjustTypesFromJSONValue(msg[field]);
+    }
+  });
+
+  return msg;
+};
+
+export function stringifyDDP(msg) {
+  const copy = clone(msg);
+
+  // swizzle 'changed' messages from 'fields undefined' rep to 'fields
+  // and cleared' rep
+  if (hasOwn.call(msg, 'fields')) {
+    const cleared = [];
+
+    Object.keys(msg.fields).forEach(key => {
+      const value = msg.fields[key];
+
+      if (typeof value === "undefined") {
+        cleared.push(key);
+        delete copy.fields[key];
+      }
+    });
+
+    if (! isEmpty(cleared)) {
+      copy.cleared = cleared;
+    }
+
+    if (isEmpty(copy.fields)) {
+      delete copy.fields;
+    }
+  }
+
+  // adjust types to basic
+  ['fields', 'params', 'result'].forEach(field => {
+    if (hasOwn.call(copy, field)) {
+      copy[field] = _adjustTypesToJSONValue(copy[field]);
+    }
+  });
+
+  if (msg.id && typeof msg.id !== 'string') {
+    throw new Error("Message id is not a string");
+  }
+
+  return JSON.stringify(copy);
+};

package/meteor/ddp/writefence.ts

@@ -0,0 +1,130 @@
+// A write fence collects a group of writes, and provides a callback
+// when all of the writes are fully committed and propagated (all
+
+import { OplogObserveDriver } from "../mongo/oplog-observe-driver";
+
+// observers have been notified of the write and acknowledged it.)
+export class _WriteFence {
+
+    public fired: boolean;
+    public _oplogObserveDrivers: Record<string, OplogObserveDriver>;
+
+    private armed: boolean;
+    private retired: boolean;
+    private outstanding_writes: number;
+    private before_fire_callbacks: Function[];
+    private completion_callbacks: Function[];
+
+    constructor () {
+        this.armed = false;
+        this.fired = false;
+        this.retired = false;
+        this.outstanding_writes = 0;
+        this.before_fire_callbacks = [];
+        this.completion_callbacks = [];
+    };
+
+    // The current write fence. When there is a current write fence, code
+    // that writes to databases should register their writes with it using
+    // beginWrite().
+    //
+    public static _CurrentWriteFence = new _WriteFence();
+
+    // Start tracking a write, and return an object to represent it. The
+    // object has a single method, committed(). This method should be
+    // called when the write is fully committed and propagated. You can
+    // continue to add writes to the WriteFence up until it is triggered
+    // (calls its callbacks because all writes have committed.)
+    beginWrite() {
+        var self = this;
+
+        if (self.retired)
+            return { committed: function () { } };
+
+        if (self.fired)
+            throw new Error("fence has already activated -- too late to add writes");
+
+        self.outstanding_writes++;
+        var committed = false;
+        return {
+            committed: function () {
+                if (committed)
+                    throw new Error("committed called twice on the same write");
+                committed = true;
+                self.outstanding_writes--;
+                self._maybeFire();
+            }
+        };
+    }
+
+    // Arm the fence. Once the fence is armed, and there are no more
+    // uncommitted writes, it will activate.
+    arm() {
+        var self = this;
+        if (self === _WriteFence._CurrentWriteFence)
+            throw Error("Can't arm the current fence");
+        self.armed = true;
+        self._maybeFire();
+    }
+
+    // Register a function to be called once before firing the fence.
+    // Callback function can add new writes to the fence, in which case
+    // it won't fire until those writes are done as well.
+    onBeforeFire(func) {
+        var self = this;
+        if (self.fired)
+            throw new Error("fence has already activated -- too late to " +
+                "add a callback");
+        self.before_fire_callbacks.push(func);
+    }
+
+    // Register a function to be called when the fence fires.
+    onAllCommitted(func) {
+        var self = this;
+        if (self.fired)
+            throw new Error("fence has already activated -- too late to " +
+                "add a callback");
+        self.completion_callbacks.push(func);
+    }
+
+    _maybeFire() {
+        var self = this;
+        if (self.fired)
+            throw new Error("write fence already activated?");
+        if (self.armed && !self.outstanding_writes) {
+            self.outstanding_writes++;
+            while (self.before_fire_callbacks.length > 0) {
+                var callbacks = self.before_fire_callbacks;
+                self.before_fire_callbacks = [];
+                for (const callback of callbacks)
+                    invokeCallback(callback, self);
+            }
+            self.outstanding_writes--;
+
+            if (!self.outstanding_writes) {
+                self.fired = true;
+                var callbacks = self.completion_callbacks;
+                self.completion_callbacks = [];
+                for (const callback of callbacks)
+                    invokeCallback(callback, self);
+            }
+        }
+    }
+
+    // Deactivate this fence so that adding more writes has no effect.
+    // The fence must have already fired.
+    retire() {
+        var self = this;
+        if (!self.fired)
+            throw new Error("Can't retire a fence that hasn't fired.");
+        self.retired = true;
+    }
+}
+
+function invokeCallback(func: Function, self: _WriteFence) {
+    try {
+        func(self);
+    } catch (err) {
+        console.error("exception in write fence callback", err);
+    }
+}

package/meteor/diff-sequence/diff.ts

@@ -0,0 +1,295 @@
+import { clone, equals } from "../ejson/ejson";
+import { IdMap } from "../id-map/id_map";
+
+interface DiffSequence {
+    diffQueryChanges(ordered: boolean, oldResults: any[], newResults: any[], observer, options?): any;
+    diffQueryChanges(ordered: boolean, oldResults: IdMap, newResults: IdMap, observer, options?): any;
+    diffQueryUnorderedChanges(oldResults, newResults, observer, options?): any;
+    diffQueryOrderedChanges(old_results, new_results, observer, options?): any;
+    diffObjects(left, right, callbacks): any;
+    diffMaps(left, right, callbacks): any;
+    makeChangedFields(newDoc, oldDoc): any;
+    applyChanges(doc, changeFields): void;
+}
+
+export const DiffSequence: DiffSequence = {} as any;
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+function isObjEmpty(obj) {
+    for (let key in Object(obj)) {
+        if (hasOwn.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// ordered: bool.
+// old_results and new_results: collections of documents.
+//    if ordered, they are arrays.
+//    if unordered, they are IdMaps
+DiffSequence.diffQueryChanges = function (ordered: boolean, oldResults: any, newResults: any, observer, options) {
+    if (ordered)
+        DiffSequence.diffQueryOrderedChanges(oldResults, newResults, observer, options);
+    else
+        DiffSequence.diffQueryUnorderedChanges(oldResults, newResults, observer, options);
+};
+
+DiffSequence.diffQueryUnorderedChanges = function (oldResults: IdMap, newResults: IdMap, observer, options) {
+    options = options || {};
+    var projectionFn = options.projectionFn || clone;
+
+    if (observer.movedBefore) {
+        throw new Error("_diffQueryUnordered called with a movedBefore observer!");
+    }
+
+    newResults.forEach(function (newDoc, id) {
+        var oldDoc = oldResults.get(id);
+        if (oldDoc) {
+            if (observer.changed && !equals(oldDoc, newDoc)) {
+                var projectedNew = projectionFn(newDoc);
+                var projectedOld = projectionFn(oldDoc);
+                var changedFields =
+                    DiffSequence.makeChangedFields(projectedNew, projectedOld);
+                if (!isObjEmpty(changedFields)) {
+                    observer.changed(id, changedFields);
+                }
+            }
+        } else if (observer.added) {
+            var fields = projectionFn(newDoc);
+            delete fields._id;
+            observer.added(newDoc._id, fields);
+        }
+    });
+
+    if (observer.removed) {
+        oldResults.forEach(function (oldDoc, id) {
+            if (!newResults.has(id))
+                observer.removed(id);
+        });
+    }
+};
+
+DiffSequence.diffQueryOrderedChanges = function (old_results: any[], new_results: any[], observer, options) {
+    options = options || {};
+    var projectionFn = options.projectionFn || clone;
+
+    var new_presence_of_id = {};
+    new_results.forEach(function (doc) {
+        if (new_presence_of_id[doc._id])
+            console.log("Duplicate _id in new_results");
+        new_presence_of_id[doc._id] = true;
+    });
+
+    var old_index_of_id = {};
+    old_results.forEach(function (doc, i) {
+        if (doc._id in old_index_of_id)
+            console.log("Duplicate _id in old_results");
+        old_index_of_id[doc._id] = i;
+    });
+
+    // ALGORITHM:
+    //
+    // To determine which docs should be considered "moved" (and which
+    // merely change position because of other docs moving) we run
+    // a "longest common subsequence" (LCS) algorithm.  The LCS of the
+    // old doc IDs and the new doc IDs gives the docs that should NOT be
+    // considered moved.
+
+    // To actually call the appropriate callbacks to get from the old state to the
+    // new state:
+
+    // First, we call removed() on all the items that only appear in the old
+    // state.
+
+    // Then, once we have the items that should not move, we walk through the new
+    // results array group-by-group, where a "group" is a set of items that have
+    // moved, anchored on the end by an item that should not move.  One by one, we
+    // move each of those elements into place "before" the anchoring end-of-group
+    // item, and fire changed events on them if necessary.  Then we fire a changed
+    // event on the anchor, and move on to the next group.  There is always at
+    // least one group; the last group is anchored by a virtual "null" id at the
+    // end.
+
+    // Asymptotically: O(N k) where k is number of ops, or potentially
+    // O(N log N) if inner loop of LCS were made to be binary search.
+
+
+    //////// LCS (longest common sequence, with respect to _id)
+    // (see Wikipedia article on Longest Increasing Subsequence,
+    // where the LIS is taken of the sequence of old indices of the
+    // docs in new_results)
+    //
+    // unmoved: the output of the algorithm; members of the LCS,
+    // in the form of indices into new_results
+    var unmoved = [];
+    // max_seq_len: length of LCS found so far
+    var max_seq_len = 0;
+    // seq_ends[i]: the index into new_results of the last doc in a
+    // common subsequence of length of i+1 <= max_seq_len
+    var N = new_results.length;
+    var seq_ends = new Array(N);
+    // ptrs:  the common subsequence ending with new_results[n] extends
+    // a common subsequence ending with new_results[ptr[n]], unless
+    // ptr[n] is -1.
+    var ptrs = new Array(N);
+    // virtual sequence of old indices of new results
+    var old_idx_seq = function (i_new) {
+        return old_index_of_id[new_results[i_new]._id];
+    };
+    // for each item in new_results, use it to extend a common subsequence
+    // of length j <= max_seq_len
+    for (var i = 0; i < N; i++) {
+        if (old_index_of_id[new_results[i]._id] !== undefined) {
+            var j = max_seq_len;
+            // this inner loop would traditionally be a binary search,
+            // but scanning backwards we will likely find a subseq to extend
+            // pretty soon, bounded for example by the total number of ops.
+            // If this were to be changed to a binary search, we'd still want
+            // to scan backwards a bit as an optimization.
+            while (j > 0) {
+                if (old_idx_seq(seq_ends[j - 1]) < old_idx_seq(i))
+                    break;
+                j--;
+            }
+
+            ptrs[i] = (j === 0 ? -1 : seq_ends[j - 1]);
+            seq_ends[j] = i;
+            if (j + 1 > max_seq_len)
+                max_seq_len = j + 1;
+        }
+    }
+
+    // pull out the LCS/LIS into unmoved
+    var idx = (max_seq_len === 0 ? -1 : seq_ends[max_seq_len - 1]);
+    while (idx >= 0) {
+        unmoved.push(idx);
+        idx = ptrs[idx];
+    }
+    // the unmoved item list is built backwards, so fix that
+    unmoved.reverse();
+
+    // the last group is always anchored by the end of the result list, which is
+    // an id of "null"
+    unmoved.push(new_results.length);
+
+    old_results.forEach(function (doc) {
+        if (!new_presence_of_id[doc._id])
+            observer.removed && observer.removed(doc._id);
+    });
+
+    // for each group of things in the new_results that is anchored by an unmoved
+    // element, iterate through the things before it.
+    var startOfGroup = 0;
+    unmoved.forEach(function (endOfGroup) {
+        var groupId = new_results[endOfGroup] ? new_results[endOfGroup]._id : null;
+        var oldDoc, newDoc, fields, projectedNew, projectedOld;
+        for (var i = startOfGroup; i < endOfGroup; i++) {
+            newDoc = new_results[i];
+            if (!hasOwn.call(old_index_of_id, newDoc._id)) {
+                fields = projectionFn(newDoc);
+                delete fields._id;
+                observer.addedBefore && observer.addedBefore(newDoc._id, fields, groupId);
+                observer.added && observer.added(newDoc._id, fields);
+            } else {
+                // moved
+                oldDoc = old_results[old_index_of_id[newDoc._id]];
+                projectedNew = projectionFn(newDoc);
+                projectedOld = projectionFn(oldDoc);
+                fields = DiffSequence.makeChangedFields(projectedNew, projectedOld);
+                if (!isObjEmpty(fields)) {
+                    observer.changed && observer.changed(newDoc._id, fields);
+                }
+                observer.movedBefore && observer.movedBefore(newDoc._id, groupId);
+            }
+        }
+        if (groupId) {
+            newDoc = new_results[endOfGroup];
+            oldDoc = old_results[old_index_of_id[newDoc._id]];
+            projectedNew = projectionFn(newDoc);
+            projectedOld = projectionFn(oldDoc);
+            fields = DiffSequence.makeChangedFields(projectedNew, projectedOld);
+            if (!isObjEmpty(fields)) {
+                observer.changed && observer.changed(newDoc._id, fields);
+            }
+        }
+        startOfGroup = endOfGroup + 1;
+    });
+
+
+};
+
+
+// General helper for diff-ing two objects.
+// callbacks is an object like so:
+// { leftOnly: function (key, leftValue) {...},
+//   rightOnly: function (key, rightValue) {...},
+//   both: function (key, leftValue, rightValue) {...},
+// }
+DiffSequence.diffObjects = function (left, right, callbacks) {
+    Object.keys(left).forEach(key => {
+        const leftValue = left[key];
+        if (hasOwn.call(right, key)) {
+            callbacks.both && callbacks.both(key, leftValue, right[key]);
+        } else {
+            callbacks.leftOnly && callbacks.leftOnly(key, leftValue);
+        }
+    });
+
+    if (callbacks.rightOnly) {
+        Object.keys(right).forEach(key => {
+            const rightValue = right[key];
+            if (!hasOwn.call(left, key)) {
+                callbacks.rightOnly(key, rightValue);
+            }
+        });
+    }
+};
+
+DiffSequence.diffMaps = function (left, right, callbacks) {
+    left.forEach(function (leftValue, key) {
+        if (right.has(key)) {
+            callbacks.both && callbacks.both(key, leftValue, right.get(key));
+        } else {
+            callbacks.leftOnly && callbacks.leftOnly(key, leftValue);
+        }
+    });
+
+    if (callbacks.rightOnly) {
+        right.forEach(function (rightValue, key) {
+            if (!left.has(key)) {
+                callbacks.rightOnly(key, rightValue);
+            }
+        });
+    }
+};
+
+
+DiffSequence.makeChangedFields = function (newDoc, oldDoc) {
+    var fields = {};
+    DiffSequence.diffObjects(oldDoc, newDoc, {
+        leftOnly: function (key, value) {
+            fields[key] = undefined;
+        },
+        rightOnly: function (key, value) {
+            fields[key] = value;
+        },
+        both: function (key, leftValue, rightValue) {
+            if (!equals(leftValue, rightValue))
+                fields[key] = rightValue;
+        }
+    });
+    return fields;
+};
+
+DiffSequence.applyChanges = function (doc, changeFields) {
+    Object.keys(changeFields).forEach(key => {
+        const value = changeFields[key];
+        if (typeof value === "undefined") {
+            delete doc[key];
+        } else {
+            doc[key] = value;
+        }
+    });
+};