mongodb-livedata-server 0.0.13 → 0.1.0

package/dist/meteor/mongo/observe_multiplexer.js

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObserveHandle = exports.ObserveMultiplexer = void 0;
 const ejson_1 = require("../ejson/ejson");
@@ -51,9 +40,8 @@ class ObserveMultiplexer {
         ++self._addHandleTasksScheduledButNotPerformed;
         await self._queue.runTask(async () => {
             self._handles[handle._id] = handle;
-            // Send out whatever adds we have so far (whether or not the
-            // multiplexer is ready).
-            self._sendAdds(handle);
+            if (this._ready() && this._cache.docs.size > 0)
+                handle._initialAdds(this._cache.docs);
             --self._addHandleTasksScheduledButNotPerformed;
         });
         // *outside* the task, since otherwise we'd deadlock
@@ -97,6 +85,13 @@ class ObserveMultiplexer {
         this._queue.queueTask(async () => {
             if (this._ready())
                 throw Error("can't make ObserveMultiplex ready twice!");
+            if (this._cache.docs.size > 0) {
+                for (const handleId of Object.keys(this._handles)) {
+                    var handle = this._handles && this._handles[handleId];
+                    if (handle)
+                        handle._initialAdds(this._cache.docs);
+                }
+            }
             this._readyFuture.resolve();
             this._readyFuture.isResolved = true;
         });
@@ -130,9 +125,9 @@ class ObserveMultiplexer {
     callbackNames() {
         var self = this;
         if (self._ordered)
-            return ["addedBefore", "changed", "movedBefore", "removed"];
+            return ["initialAdds", "addedBefore", "changed", "movedBefore", "removed"];
         else
-            return ["added", "changed", "removed"];
+            return ["initialAdds", "added", "changed", "removed"];
     }
     _ready() {
         return this._readyFuture.isResolved;
@@ -151,6 +146,9 @@ class ObserveMultiplexer {
                 (callbackName !== 'added' && callbackName !== 'addedBefore')) {
                 throw new Error("Got " + callbackName + " during initial adds");
             }
+            // don't actually send anything to the handles until initial adds are cached
+            if (!self._ready())
+                return;
             // Now multiplex the callbacks out to all observe handles. It's OK if
             // these calls yield; since we're inside a task, no other use of our queue
             // can continue until these are done. (But we do have to be careful to not
@@ -166,28 +164,6 @@ class ObserveMultiplexer {
             }
         });
     }
-    // Sends initial adds to a handle. It should only be called from within a task
-    // (the task that is processing the addHandleAndSendInitialAdds call). It
-    // synchronously invokes the handle's added or addedBefore; there's no need to
-    // flush the queue afterwards to ensure that the callbacks get out.
-    _sendAdds(handle) {
-        var self = this;
-        //if (self._queue.safeToRunTask())
-        //    throw Error("_sendAdds may only be called from within a task!");
-        var add = self._ordered ? handle._addedBefore : handle._added;
-        if (!add)
-            return;
-        // note: docs may be an _IdMap or an OrderedDict
-        self._cache.docs.forEach((doc, id) => {
-            if (!self._handles.hasOwnProperty(handle._id))
-                throw Error("handle got removed before sending initial adds!");
-            const _a = handle.nonMutatingCallbacks ? doc : (0, ejson_1.clone)(doc), { _id } = _a, fields = __rest(_a, ["_id"]);
-            if (self._ordered)
-                add(id, fields, null); // we're going in order, so add at end
-            else
-                add(id, fields);
-        });
-    }
 }
 exports.ObserveMultiplexer = ObserveMultiplexer;
 let nextObserveHandleId = 1;

package/dist/meteor/mongo/oplog-observe-driver.d.ts

@@ -3,7 +3,6 @@ import { MinimongoMatcher } from "./minimongo_matcher";
 import MinimongoSorter from "./minimongo_sorter";
 import { ObserveMultiplexer } from "./observe_multiplexer";
 import { CursorDescription } from "./live_cursor";
-import { IdMap } from "../id-map/id_map";
 import { SynchronousCursor } from "./synchronous-cursor";
 interface OplogObserveDriverOptions {
     cursorDescription: CursorDescription<any>;
@@ -53,13 +52,15 @@ export declare class OplogObserveDriver {
     _handleOplogEntrySteadyOrFetching(op: any): void;
     _runInitialQuery(): Promise<void>;
     _pollQuery(): void;
-    _runQuery(options?: any): Promise<void>;
+    _runQuery(options?: {
+        initial?: boolean;
+    }): Promise<void>;
     _needToPollQuery(): void;
     _doneQuerying(): Promise<void>;
     _cursorForQuery(optionsOverwrite: {
         limit: number;
     }): SynchronousCursor;
-    _publishNewResults(newResults: IdMap, newBuffer: IdMap): void;
+    _publishNewResults(newResults: Map<string, any>, newBuffer: Map<string, any>): void;
     stop(): void;
     _registerPhaseChange(phase: any): void;
     static cursorSupported(cursorDescription: CursorDescription<any>, matcher: MinimongoMatcher): boolean;

package/dist/meteor/mongo/oplog-observe-driver.js

@@ -11,7 +11,6 @@ const max_heap_1 = require("../binary-heap/max_heap");
 const minimongo_common_1 = require("./minimongo_common");
 const ejson_1 = require("../ejson/ejson");
 const oplog_tailing_1 = require("./oplog_tailing");
-const id_map_1 = require("../id-map/id_map");
 const synchronous_cursor_1 = require("./synchronous-cursor");
 var PHASE;
 (function (PHASE) {
@@ -77,7 +76,7 @@ class OplogObserveDriver {
             self._comparator = null;
             self._sorter = null;
             self._unpublishedBuffer = null;
-            self._published = new id_map_1.IdMap();
+            self._published = new Map();
         }
         // Indicates if it is safe to insert a new document at the end of the buffer
         // for this query. i.e. it is known that there are no documents matching the
@@ -187,11 +186,11 @@ class OplogObserveDriver {
         // (exceeding capacity specified by limit). If so, push the maximum
         // element to the buffer, we might want to save it in memory to reduce the
         // amount of Mongo lookups in the future.
-        if (self._limit && self._published.size() > self._limit) {
+        if (self._limit && self._published.size > self._limit) {
             // XXX in theory the size of published is no more than limit+1
-            if (self._published.size() !== self._limit + 1) {
+            if (self._published.size !== self._limit + 1) {
                 throw new Error("After adding to published, " +
-                    (self._published.size() - self._limit) +
+                    (self._published.size - self._limit) +
                     " documents are overflowing the set");
             }
             var overflowingDocId = self._published.maxElementId();
@@ -199,7 +198,7 @@ class OplogObserveDriver {
             if ((0, ejson_1.equals)(overflowingDocId, id)) {
                 throw new Error("The document just added is overflowing the published set");
             }
-            self._published.remove(overflowingDocId);
+            self._published.delete(overflowingDocId);
             self._multiplexer.removed(overflowingDocId);
             self._addBuffered(overflowingDocId, overflowingDoc);
         }
@@ -208,11 +207,11 @@ class OplogObserveDriver {
     _removePublished(id) {
         var self = this;
         //Meteor._noYieldsAllowed(function () {
-        self._published.remove(id);
+        self._published.delete(id);
         self._multiplexer.removed(id);
-        if (!self._limit || self._published.size() === self._limit)
+        if (!self._limit || self._published.size === self._limit)
             return;
-        if (self._published.size() > self._limit)
+        if (self._published.size > self._limit)
             throw Error("self._published got too big");
         // OK, we are publishing less than the limit. Maybe we should look in the
         // buffer to find the next element past what we were publishing before.
@@ -264,9 +263,9 @@ class OplogObserveDriver {
         //Meteor._noYieldsAllowed(function () {
         self._unpublishedBuffer.set(id, self._sharedProjectionFn(doc));
         // If something is overflowing the buffer, we just remove it from cache
-        if (self._unpublishedBuffer.size() > self._limit) {
+        if (self._unpublishedBuffer.size > self._limit) {
             var maxBufferedId = self._unpublishedBuffer.maxElementId();
-            self._unpublishedBuffer.remove(maxBufferedId);
+            self._unpublishedBuffer.delete(maxBufferedId);
             // Since something matching is removed from cache (both published set and
             // buffer), set flag to false
             self._safeAppendToBuffer = false;
@@ -278,11 +277,11 @@ class OplogObserveDriver {
     _removeBuffered(id) {
         var self = this;
         //Meteor._noYieldsAllowed(function () {
-        self._unpublishedBuffer.remove(id);
+        self._unpublishedBuffer.delete(id);
         // To keep the contract "buffer is never empty in STEADY phase unless the
         // everything matching fits into published" true, we poll everything as
         // soon as we see the buffer becoming empty.
-        if (!self._unpublishedBuffer.size() && !self._safeAppendToBuffer)
+        if (!self._unpublishedBuffer.size && !self._safeAppendToBuffer)
             self._needToPollQuery();
         //});
     }
@@ -299,22 +298,22 @@ class OplogObserveDriver {
             throw Error("tried to add something already existed in buffer " + id);
         var limit = self._limit;
         var comparator = self._comparator;
-        var maxPublished = (limit && self._published.size() > 0)
+        var maxPublished = (limit && self._published.size > 0)
             ? self._published.get(self._published.maxElementId()) // published is MaxHeap because limit is defined
             : null;
-        var maxBuffered = (limit && self._unpublishedBuffer.size() > 0)
+        var maxBuffered = (limit && self._unpublishedBuffer.size > 0)
             ? self._unpublishedBuffer.get(self._unpublishedBuffer.maxElementId())
             : null;
         // The query is unlimited or didn't publish enough documents yet or the
         // new document would fit into published set pushing the maximum element
         // out, then we need to publish the doc.
-        var toPublish = !limit || self._published.size() < limit ||
+        var toPublish = !limit || self._published.size < limit ||
             comparator(doc, maxPublished) < 0;
         // Otherwise we might need to buffer it (only in case of limited query).
         // Buffering is allowed if the buffer is not filled up yet and all
         // matching docs are either in the published set or in the buffer.
         var canAppendToBuffer = !toPublish && self._safeAppendToBuffer &&
-            self._unpublishedBuffer.size() < limit;
+            self._unpublishedBuffer.size < limit;
         // Or if it is small enough to be safely inserted to the middle or the
         // beginning of the buffer.
         var canInsertIntoBuffer = !toPublish && maxBuffered &&
@@ -364,7 +363,7 @@ class OplogObserveDriver {
         else if (cachedBefore && matchesNow) {
             var oldDoc = self._published.get(id);
             var comparator = self._comparator;
-            var minBuffered = self._limit && self._unpublishedBuffer.size() &&
+            var minBuffered = self._limit && self._unpublishedBuffer.size &&
                 self._unpublishedBuffer.get(self._unpublishedBuffer.minElementId());
             var maxBuffered;
             if (publishedBefore) {
@@ -378,7 +377,7 @@ class OplogObserveDriver {
                 // published. Notably, we don't want to schedule repoll and continue
                 // relying on this property.
                 var staysInPublished = !self._limit ||
-                    self._unpublishedBuffer.size() === 0 ||
+                    self._unpublishedBuffer.size === 0 ||
                     comparator(newDoc, minBuffered) <= 0;
                 if (staysInPublished) {
                     self._changePublished(id, oldDoc, newDoc);
@@ -405,10 +404,10 @@ class OplogObserveDriver {
                 // we don't trigger the querying immediately.  if we end this block
                 // with the buffer empty, we will need to trigger the query poll
                 // manually too.
-                self._unpublishedBuffer.remove(id);
+                self._unpublishedBuffer.delete(id);
                 // published is MaxHeap because bufferedBefore is only set when limit is defined
                 var maxPublished = self._published.get(self._published.maxElementId());
-                maxBuffered = self._unpublishedBuffer.size() && self._unpublishedBuffer.get(self._unpublishedBuffer.maxElementId());
+                maxBuffered = self._unpublishedBuffer.size && self._unpublishedBuffer.get(self._unpublishedBuffer.maxElementId());
                 // the buffered doc was updated, it could move to published
                 var toPublish = comparator(newDoc, maxPublished) < 0;
                 // or stays in buffer even after the change
@@ -427,7 +426,7 @@ class OplogObserveDriver {
                     self._safeAppendToBuffer = false;
                     // Normally this check would have been done in _removeBuffered but
                     // we didn't use it, so we need to do it ourself now.
-                    if (!self._unpublishedBuffer.size()) {
+                    if (!self._unpublishedBuffer.size) {
                         self._needToPollQuery();
                     }
                 }
@@ -667,8 +666,8 @@ class OplogObserveDriver {
             // If we've been stopped, we don't have to run anything any more.
             if (self._stopped)
                 return;
-            newResults = new id_map_1.IdMap();
-            newBuffer = new id_map_1.IdMap();
+            newResults = new Map();
+            newBuffer = new Map();
             // Query 2x documents as the half excluded from the original query will go
             // into unpublished buffer to reduce additional Mongo lookups in cases
             // when documents are removed from the published set and need a
@@ -809,7 +808,7 @@ class OplogObserveDriver {
         // Sanity-check that everything we tried to put into _published ended up
         // there.
         // XXX if this is slow, remove it later
-        if (self._published.size() !== newResults.size()) {
+        if (self._published.size !== newResults.size) {
             console.error('The Mongo server and the Meteor query disagree on how ' +
                 'many documents match your query. Cursor description: ', self._cursorDescription);
             throw Error("The Mongo server and the Meteor query disagree on how " +
@@ -825,7 +824,7 @@ class OplogObserveDriver {
         newBuffer.forEach(function (doc, id) {
             self._addBuffered(id, doc);
         });
-        self._safeAppendToBuffer = newBuffer.size() < self._limit;
+        self._safeAppendToBuffer = newBuffer.size < self._limit;
         //});
     }
     // This stop function is invoked from the onStop of the ObserveMultiplexer, so

package/dist/meteor/mongo/polling_observe_driver.js

@@ -1,11 +1,17 @@
 "use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingObserveDriver = void 0;
 const writefence_1 = require("../ddp/writefence");
 const diff_1 = require("../diff-sequence/diff");
 const synchronous_queue_1 = require("./synchronous-queue");
 const observe_driver_utils_1 = require("./observe_driver_utils");
-const id_map_1 = require("../id-map/id_map");
 var POLLING_THROTTLE_MS = +process.env.METEOR_POLLING_THROTTLE_MS || 50;
 var POLLING_INTERVAL_MS = +process.env.METEOR_POLLING_INTERVAL_MS || 10 * 1000;
 class PollingObserveDriver {
@@ -69,6 +75,7 @@ class PollingObserveDriver {
         self._taskQueue.queueTask(async () => await self._pollMongo());
     }
     async _pollMongo() {
+        var _a, e_1, _b, _c;
         var self = this;
         --self._pollsScheduledButNotStarted;
         if (self._stopped)
@@ -79,7 +86,7 @@ class PollingObserveDriver {
         if (!oldResults) {
             first = true;
             // XXX maybe use OrderedDict instead?
-            oldResults = self._ordered ? [] : new id_map_1.IdMap();
+            oldResults = self._ordered ? [] : new Map();
         }
         // Save the list of pending writes which this round will commit.
         var writesForCycle = self._pendingWrites;
@@ -88,8 +95,27 @@ class PollingObserveDriver {
         try {
             const cursor = self._mongoHandle.db.collection(self._cursorDescription.collectionName).find(self._cursorDescription.selector);
             if (!self._ordered) {
-                newResults = new id_map_1.IdMap();
-                await cursor.forEach((doc) => newResults.set(doc._id, doc));
+                newResults = new Map();
+                try {
+                    for (var _d = true, cursor_1 = __asyncValues(cursor), cursor_1_1; cursor_1_1 = await cursor_1.next(), _a = cursor_1_1.done, !_a;) {
+                        _c = cursor_1_1.value;
+                        _d = false;
+                        try {
+                            const doc = _c;
+                            newResults.set(doc._id, doc);
+                        }
+                        finally {
+                            _d = true;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = cursor_1.return)) await _b.call(cursor_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
             }
             else
                 newResults = await cursor.toArray();

package/dist/meteor/ordered-dict/ordered_dict.d.ts

@@ -10,12 +10,12 @@ export declare class OrderedDict {
     constructor(...args: any[]);
     _k(key: any): string;
     empty(): boolean;
-    size(): number;
+    get size(): number;
     _linkEltIn(elt: any): void;
     _linkEltOut(elt: any): void;
     putBefore(key: any, item: any, before: any): void;
     append(key: any, item: any): void;
-    remove(key: any): any;
+    delete(key: any): any;
     get(key: any): any;
     has(key: any): any;
     forEach(iter: (doc: any, key: string, index: number) => any, context?: any): void;

package/dist/meteor/ordered-dict/ordered_dict.js

@@ -38,7 +38,7 @@ class OrderedDict {
     empty() {
         return !this._first;
     }
-    size() {
+    get size() {
         return this._size;
     }
     _linkEltIn(elt) {
@@ -82,7 +82,7 @@ class OrderedDict {
     append(key, item) {
         this.putBefore(key, item, null);
     }
-    remove(key) {
+    delete(key) {
         var elt = this._dict[this._k(key)];
         if (typeof elt === "undefined")
             throw new Error("Item " + key + " not present in OrderedDict");