mongodb-livedata-server 0.0.7 → 0.0.9

package/dist/meteor/ddp/livedata_server.d.ts

@@ -121,8 +121,8 @@ export declare class DDPServer {
     _urlForSession(sessionId: any): string;
 }
 export declare function _calculateVersion(clientSupportedVersions: any, serverSupportedVersions: any): any;
-export declare function wrapInternalException(exception: any, context: any): any;
-export declare function maybeAuditArgumentChecks(f: Function, context: any, args: any[] | null, description: string): any;
+export declare function wrapInternalException(exception: any, context: string): any;
+export declare function maybeAuditArgumentChecks<T>(f: (...args: any[]) => T, context: any, args: any[] | null, description: string): T;
 export declare function ddpError(error: string | number, reason?: string, details?: string): {
     isClientSafe: boolean;
     error: string | number;

package/dist/meteor/ddp/method-invocation.d.ts

@@ -1,3 +1,12 @@
+import { SessionConnectionHandle } from "./session";
+interface MethodInvocationOptions {
+    isSimulation: boolean;
+    isFromCallAsync?: boolean;
+    userId: string;
+    setUserId: (userId: string) => void;
+    connection: SessionConnectionHandle;
+    randomSeed: number;
+}
 /**
  * @summary The state for a single invocation of a method, referenced by this
  * inside a method definition.
@@ -7,13 +16,13 @@
  */
 export declare class MethodInvocation {
     userId: string;
-    connection: any;
+    connection: SessionConnectionHandle;
     private isSimulation;
     private _isFromCallAsync;
     private _setUserId;
     private randomSeed;
     private randomStream;
-    constructor(options: any);
+    constructor(options: MethodInvocationOptions);
     /**
      * @summary Set the logged in user.
      * @locus Server
@@ -23,3 +32,4 @@ export declare class MethodInvocation {
      */
     setUserId(userId: string | null): void;
 }
+export {};

package/dist/meteor/ddp/method-invocation.js

@@ -1,8 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MethodInvocation = void 0;
 // Instance name is this because it is usually referred to as this inside a
 // method definition
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodInvocation = void 0;
 /**
  * @summary The state for a single invocation of a method, referenced by this
  * inside a method definition.

package/dist/meteor/ddp/session-collection-view.d.ts

@@ -1,11 +1,5 @@
 import { SessionDocumentView } from "./session-document-view";
-interface SubscriptionCallbacks {
-    added: (collectionName: string, id: string, fields: Record<string, any>) => void;
-    changed: (collectionName: string, id: string, fields: Record<string, any>) => void;
-    removed: (collectionName: string, id: string) => void;
-}
-interface SubscriptionHandle {
-}
+import { SubscriptionCallbacks, SubscriptionHandle } from "./subscription";
 /**
  * Represents a client's view of a single collection
  * @param {String} collectionName Name of the collection it represents
@@ -22,6 +16,5 @@ export declare class SessionCollectionView {
     diffDocument(id: string, prevDV: SessionDocumentView, nowDV: SessionDocumentView): void;
     added(subscriptionHandle: SubscriptionHandle, id: string, fields: Record<string, any>): void;
     changed(subscriptionHandle: SubscriptionHandle, id: string, changed: Record<string, any>): void;
-    removed(subscriptionHandle: any, id: string): void;
+    removed(subscriptionHandle: SubscriptionHandle, id: string): void;
 }
-export {};

package/dist/meteor/ddp/session-collection-view.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionCollectionView = void 0;
 const diff_1 = require("../diff-sequence/diff");
 const ejson_1 = require("../ejson/ejson");
+const id_map_1 = require("../id-map/id_map");
 const session_document_view_1 = require("./session-document-view");
 /**
  * Represents a client's view of a single collection
@@ -14,10 +15,10 @@ class SessionCollectionView {
     constructor(collectionName, callbacks) {
         this.collectionName = collectionName;
         this.callbacks = callbacks;
-        this.documents = new Map();
+        this.documents = new id_map_1.IdMap();
     }
     isEmpty() {
-        return this.documents.size === 0;
+        return this.documents.empty();
     }
     diff(previous) {
         diff_1.DiffSequence.diffMaps(previous.documents, this.documents, {
@@ -90,7 +91,7 @@ class SessionCollectionView {
         if (docView.existsIn.size === 0) {
             // it is gone from everyone
             self.callbacks.removed(self.collectionName, id);
-            self.documents.delete(id);
+            self.documents.remove(id);
         }
         else {
             var changed = {};

package/dist/meteor/ddp/session.d.ts

@@ -1,6 +1,7 @@
 import DoubleEndedQueue from "double-ended-queue";
 import { StreamServerSocket } from "./stream_server";
 import { DDPServer } from "./livedata_server";
+import { SubscriptionHandle } from "./subscription";
 export interface SessionConnectionHandle {
     id: string;
     close: Function;
@@ -38,7 +39,7 @@ export declare class DDPSession {
     private _respondToPings;
     private heartbeat;
     constructor(server: DDPServer, version: string, socket: StreamServerSocket, options: any);
-    sendReady(subscriptionIds: any): void;
+    sendReady(subscriptionIds: string[]): void;
     _canSend(collectionName: any): boolean;
     sendAdded(collectionName: string, id: string, fields: Record<string, any>): void;
     sendChanged(collectionName: string, id: string, fields: Record<string, any>): void;
@@ -48,10 +49,10 @@ export declare class DDPSession {
         changed: any;
         removed: any;
     };
-    getCollectionView(collectionName: any): any;
-    added(subscriptionHandle: any, collectionName: any, id: any, fields: any): void;
-    removed(subscriptionHandle: any, collectionName: any, id: any): void;
-    changed(subscriptionHandle: any, collectionName: any, id: any, fields: any): void;
+    getCollectionView(collectionName: string): any;
+    added(subscriptionHandle: SubscriptionHandle, collectionName: string, id: string, fields: Record<string, any>): void;
+    removed(subscriptionHandle: SubscriptionHandle, collectionName: string, id: string): void;
+    changed(subscriptionHandle: SubscriptionHandle, collectionName: string, id: string, fields: Record<string, any>): void;
     startUniversalSubs(): void;
     close(): void;
     send(msg: any): void;
@@ -61,7 +62,7 @@ export declare class DDPSession {
     _eachSub(f: any): void;
     _diffCollectionViews(beforeCVs: any): void;
     _setUserId(userId: any): void;
-    _startSubscription(handler: any, subId?: any, params?: any, name?: any): void;
+    _startSubscription(handler: any, subId?: any, params?: any, name?: any): Promise<void>;
     _stopSubscription(subId: any, error?: any): void;
     _deactivateAllSubscriptions(): void;
     _clientAddress(): string;

package/dist/meteor/ddp/session.js

@@ -14,6 +14,7 @@ const utils_1 = require("./utils");
 const diff_1 = require("../diff-sequence/diff");
 const session_collection_view_1 = require("./session-collection-view");
 const subscription_1 = require("./subscription");
+const id_map_1 = require("../id-map/id_map");
 class DDPSession {
     constructor(server, version, socket, options) {
         this.protocol_handlers = {
@@ -139,6 +140,8 @@ class DDPSession {
                     self.send(payload);
                 }, (exception) => {
                     finish();
+                    if (exception && !exception.isClientSafe)
+                        console.error(`Exception while invoking method '${msg.method}'`, exception);
                     payload.error = (0, livedata_server_1.wrapInternalException)(exception, `while invoking method '${msg.method}'`);
                     self.send(payload);
                 });
@@ -158,7 +161,7 @@ class DDPSession {
         self._namedSubs = new Map();
         self._universalSubs = [];
         self.userId = null;
-        self.collectionViews = new Map();
+        self.collectionViews = new id_map_1.IdMap();
         // Set this to false to not send messages when collectionViews are
         // modified. This is done when rerunning subs in _setUserId and those messages
         // are calculated via a diff instead.
@@ -277,7 +280,7 @@ class DDPSession {
             const view = this.getCollectionView(collectionName);
             view.removed(subscriptionHandle, id);
             if (view.isEmpty()) {
-                this.collectionViews.delete(collectionName);
+                this.collectionViews.remove(collectionName);
             }
         }
         else {
@@ -313,7 +316,7 @@ class DDPSession {
             return;
         // Drop the merge box data immediately.
         self.inQueue = null;
-        self.collectionViews = new Map();
+        self.collectionViews = new id_map_1.IdMap();
         if (self.heartbeat) {
             self.heartbeat.stop();
             self.heartbeat = null;
@@ -454,7 +457,7 @@ class DDPSession {
         // update the userId.
         self._isSending = false;
         var beforeCVs = self.collectionViews;
-        self.collectionViews = new Map();
+        self.collectionViews = new id_map_1.IdMap();
         self.userId = userId;
         // _setUserId is normally called from a Meteor method with
         // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not
@@ -488,19 +491,19 @@ class DDPSession {
         // this diff, so that other changes cannot interleave.
         self._isSending = true;
         self._diffCollectionViews(beforeCVs);
-        if (!self._pendingReady || self._pendingReady.length === 0) {
+        if (self._pendingReady.length > 0) {
             self.sendReady(self._pendingReady);
             self._pendingReady = [];
         }
     }
-    _startSubscription(handler, subId, params, name) {
+    async _startSubscription(handler, subId, params, name) {
         var self = this;
         var sub = new subscription_1.Subscription(self, handler, subId, params, name);
         if (subId)
             self._namedSubs.set(subId, sub);
         else
             self._universalSubs.push(sub);
-        sub._runHandler();
+        await sub._runHandler();
     }
     // Tear down specified subscription
     _stopSubscription(subId, error) {

package/dist/meteor/ddp/subscription.d.ts

@@ -1,4 +1,7 @@
+import { AsyncFunction } from "../types";
 import { DDPSession, SessionConnectionHandle } from "./session";
+export declare type SubscriptionHandle = `N${string}` | `U${string}`;
+export declare type SubscriptionCallbacks = Pick<Subscription, "added" | "changed" | "removed">;
 /**
  * @summary The server's side of a subscription
  * @class Subscription
@@ -19,9 +22,9 @@ export declare class Subscription {
     private _ready;
     userId: string | null;
     private _idFilter;
-    constructor(_session: DDPSession, _handler: any, _subscriptionId: string, _params?: any[], _name?: string);
-    _runHandler(): void;
-    _publishHandlerResult(res: any): void;
+    constructor(_session: DDPSession, _handler: (...args: any[]) => any | AsyncFunction, _subscriptionId: string, _params?: any[], _name?: string);
+    _runHandler(): Promise<void>;
+    _publishHandlerResult(res: any): Promise<void>;
     _deactivate(): void;
     _callStopCallbacks(): void;
     _removeAllDocuments(): void;

package/dist/meteor/ddp/subscription.js

@@ -68,7 +68,7 @@ class Subscription {
         this.userId = this._session.userId;
     }
     ;
-    _runHandler() {
+    async _runHandler() {
         // XXX should we unblock() here? Either before running the publish
         // function, or before running _publishCursor.
         //
@@ -100,13 +100,20 @@ class Subscription {
         // or thenable and will be resolved asynchronously.
         const isThenable = resultOrThenable && typeof resultOrThenable.then === 'function';
         if (isThenable) {
-            Promise.resolve(resultOrThenable).then((...args) => this._publishHandlerResult.bind(this)(...args), e => this.error(e));
+            let result;
+            try {
+                result = await resultOrThenable;
+            }
+            catch (e) {
+                this.error(e);
+            }
+            await this._publishHandlerResult(result);
         }
         else {
-            this._publishHandlerResult(resultOrThenable);
+            await this._publishHandlerResult(resultOrThenable);
         }
     }
-    _publishHandlerResult(res) {
+    async _publishHandlerResult(res) {
         // SPECIAL CASE: Instead of writing their own callbacks that invoke
         // this.added/changed/ready/etc, the user can just return a collection
         // cursor or array of cursors from the publish function; we call their
@@ -129,7 +136,7 @@ class Subscription {
         };
         if (isCursor(res)) {
             try {
-                res._publishCursor(self);
+                await res._publishCursor(self);
             }
             catch (e) {
                 self.error(e);
@@ -161,7 +168,7 @@ class Subscription {
             ;
             try {
                 for (const cur of res) {
-                    cur._publishCursor(self);
+                    await cur._publishCursor(self);
                 }
             }
             catch (e) {

package/dist/meteor/diff-sequence/diff.d.ts

@@ -1,13 +1,18 @@
 import { IdMap } from "../id-map/id_map";
+interface DiffCallbacks {
+    both: (key: string, left: any, right: any) => void;
+    leftOnly: (key: string, value: any) => void;
+    rightOnly: (key: string, value: any) => void;
+}
 interface DiffSequence {
     diffQueryChanges(ordered: boolean, oldResults: any[], newResults: any[], observer: any, options?: any): any;
     diffQueryChanges(ordered: boolean, oldResults: IdMap, newResults: IdMap, observer: any, options?: any): any;
     diffQueryUnorderedChanges(oldResults: any, newResults: any, observer: any, options?: any): any;
     diffQueryOrderedChanges(old_results: any, new_results: any, observer: any, options?: any): any;
-    diffObjects(left: any, right: any, callbacks: any): any;
-    diffMaps(left: any, right: any, callbacks: any): any;
-    makeChangedFields(newDoc: any, oldDoc: any): any;
-    applyChanges(doc: any, changeFields: any): void;
+    diffObjects(left: Record<string, any>, right: Record<string, any>, callbacks: DiffCallbacks): any;
+    diffMaps(left: IdMap, right: IdMap, callbacks: DiffCallbacks): any;
+    makeChangedFields(newDoc: Record<string, any>, oldDoc: Record<string, any>): any;
+    applyChanges(doc: Record<string, any>, changeFields: Record<string, any>): void;
 }
 export declare const DiffSequence: DiffSequence;
 export {};

package/dist/meteor/id-map/id_map.d.ts

@@ -9,7 +9,7 @@ export declare class IdMap {
     has(id: any): boolean;
     empty(): boolean;
     clear(): void;
-    forEach(iterator: any): void;
+    forEach(iterator: (doc: any, key: string) => any): void;
     size(): number;
     setDefault(id: any, def: any): any;
     clone(): IdMap;

package/dist/meteor/mongo/caching_change_observer.d.ts

@@ -1,6 +1,7 @@
+import { IdMap } from "../id-map/id_map";
 import { OrderedDict } from "../ordered-dict/ordered_dict";
 export declare class _CachingChangeObserver {
-    docs: OrderedDict | Map<string, any>;
+    docs: OrderedDict | IdMap;
     applyChange: {
         added?: (id: string, fields: any) => void;
         changed?: (id: string, fields: any) => void;

package/dist/meteor/mongo/caching_change_observer.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._CachingChangeObserver = void 0;
 const diff_1 = require("../diff-sequence/diff");
 const ejson_1 = require("../ejson/ejson");
+const id_map_1 = require("../id-map/id_map");
 const ordered_dict_1 = require("../ordered-dict/ordered_dict");
 // available as `this` to those callbacks.
 class _CachingChangeObserver {
@@ -57,7 +58,7 @@ class _CachingChangeObserver {
             };
         }
         else {
-            this.docs = new Map();
+            this.docs = new id_map_1.IdMap();
             this.applyChange = {
                 added: (id, fields) => {
                     // Take a shallow copy since the top-level properties can be changed
@@ -86,7 +87,7 @@ class _CachingChangeObserver {
             if (callbacks.removed) {
                 callbacks.removed.call(this, id);
             }
-            this.docs.delete(id);
+            this.docs.remove(id);
         };
     }
 }

package/dist/meteor/mongo/live_connection.d.ts

@@ -2,6 +2,7 @@ import { Db } from "mongodb";
 import { CursorDescription } from "./live_cursor";
 import { OplogHandle } from "./oplog_tailing";
 import { DocFetcher } from "./doc_fetcher";
+import { ObserveCallbacks } from "./observe_multiplexer";
 export declare class LiveMongoConnection {
     private client;
     db: Db;
@@ -14,9 +15,9 @@ export declare class LiveMongoConnection {
     tail<T>(cursorDescription: CursorDescription<T>, docCallback: (doc: T) => void, timeoutMS?: number): {
         stop: () => void;
     };
-    _observeChanges(cursorDescription: CursorDescription<any>, ordered: boolean, callbacks: any, nonMutatingCallbacks: boolean): {
+    _observeChanges(cursorDescription: CursorDescription<any>, ordered: boolean, callbacks: ObserveCallbacks, nonMutatingCallbacks: boolean): Promise<{
         stop: () => void;
-    };
+    }>;
     _observeChangesTailable(cursorDescription: CursorDescription<any>, ordered: boolean, callbacks: any): {
         stop: () => void;
     };

package/dist/meteor/mongo/live_connection.js

@@ -129,7 +129,7 @@ class LiveMongoConnection {
             }
         };
     }
-    _observeChanges(cursorDescription, ordered, callbacks, nonMutatingCallbacks) {
+    async _observeChanges(cursorDescription, ordered, callbacks, nonMutatingCallbacks) {
         var self = this;
         if (cursorDescription.options.tailable) {
             return self._observeChangesTailable(cursorDescription, ordered, callbacks);
@@ -203,7 +203,7 @@ class LiveMongoConnection {
             });
         }
         // Blocks until the initial adds have been sent.
-        multiplexer.addHandleAndSendInitialAdds(observeHandle);
+        await multiplexer.addHandleAndSendInitialAdds(observeHandle);
         return observeHandle;
     }
     // observeChanges for tailable cursors on capped collections.

package/dist/meteor/mongo/live_cursor.d.ts

@@ -18,8 +18,8 @@ export declare class LiveCursor<T> {
     mongo: LiveMongoConnection;
     cursorDescription: CursorDescription<T>;
     constructor(mongo: LiveMongoConnection, collectionName: string, selector: MongoDB.Filter<MongoDB.WithId<T>>, options: CustomFindOptions<MongoDB.WithId<T>>);
-    _publishCursor(sub: Subscription): {
+    _publishCursor(sub: Subscription): Promise<{
         stop: () => void;
-    };
+    }>;
 }
 export {};

package/dist/meteor/mongo/live_cursor.js

@@ -17,8 +17,8 @@ class LiveCursor {
         this.mongo = mongo;
         this.cursorDescription = new CursorDescription(collectionName, selector, options);
     }
-    _publishCursor(sub) {
-        const observeHandle = this.mongo._observeChanges(this.cursorDescription, false, {
+    async _publishCursor(sub) {
+        const observeHandle = await this.mongo._observeChanges(this.cursorDescription, false, {
             added: (id, fields) => {
                 sub.added(this.cursorDescription.collectionName, id, fields);
             },

package/dist/meteor/mongo/observe_multiplexer.d.ts

@@ -1,3 +1,11 @@
+export interface ObserveCallbacks {
+    added: (id: string, fields: Record<string, any>) => void;
+    changed: (id: string, fields: Record<string, any>) => void;
+    removed: (id: string) => void;
+    addedBefore?: (id: string, fields: Record<string, any>, before?: any) => void;
+    movedBefore?: (id: string, fields: Record<string, any>, before?: any) => void;
+    _testOnlyPollCallback?: any;
+}
 export declare class ObserveMultiplexer {
     private _ordered;
     private _onStop;
@@ -6,9 +14,9 @@ export declare class ObserveMultiplexer {
     private _readyFuture;
     private _cache;
     private _addHandleTasksScheduledButNotPerformed;
-    added: (id: string, fields: Record<string, any>) => void;
-    changed: (id: string, fields: Record<string, any>) => void;
-    removed: (id: string) => void;
+    added: ObserveCallbacks["added"];
+    changed: ObserveCallbacks["changed"];
+    removed: ObserveCallbacks["removed"];
     constructor(options: any);
     addHandleAndSendInitialAdds(handle: ObserveHandle): Promise<void>;
     removeHandle(id: number): void;
@@ -18,19 +26,19 @@ export declare class ObserveMultiplexer {
     onFlush(cb: any): void;
     callbackNames(): string[];
     _ready(): boolean;
-    _applyCallback(callbackName: string, args: any): void;
+    _applyCallback(callbackName: string, args: any): Promise<void>;
     _sendAdds(handle: ObserveHandle): void;
 }
 export declare class ObserveHandle {
     private _multiplexer;
     nonMutatingCallbacks: boolean;
     _id: number;
-    _addedBefore: Function;
-    _movedBefore: Function;
-    _added: Function;
-    _changed: Function;
-    _removed: Function;
+    _addedBefore: ObserveCallbacks["addedBefore"];
+    _movedBefore: ObserveCallbacks["movedBefore"];
+    _added: ObserveCallbacks["added"];
+    _changed: ObserveCallbacks["changed"];
+    _removed: ObserveCallbacks["removed"];
     private _stopped;
-    constructor(_multiplexer: ObserveMultiplexer, callbacks: Record<string, Function>, nonMutatingCallbacks?: boolean);
+    constructor(_multiplexer: ObserveMultiplexer, callbacks: ObserveCallbacks, nonMutatingCallbacks?: boolean);
     stop(): void;
 }

package/dist/meteor/mongo/observe_multiplexer.js

@@ -35,8 +35,8 @@ class ObserveMultiplexer {
         // callback.
         self._addHandleTasksScheduledButNotPerformed = 0;
         for (const callbackName of self.callbackNames()) {
-            self[callbackName] = function ( /* ... */) {
-                self._applyCallback(callbackName, Array.from(arguments));
+            self[callbackName] = async function ( /* ... */) {
+                await self._applyCallback(callbackName, Array.from(arguments));
             };
         }
     }
@@ -51,7 +51,7 @@ 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 we the
+            // Send out whatever adds we have so far (whether or not the
             // multiplexer is ready).
             self._sendAdds(handle);
             --self._addHandleTasksScheduledButNotPerformed;
@@ -78,7 +78,7 @@ class ObserveMultiplexer {
         }
     }
     _stop(options) {
-        var self = this;
+        const self = this;
         options = options || {};
         // It shouldn't be possible for us to stop when all our handles still
         // haven't been returned from observeChanges!
@@ -94,12 +94,11 @@ class ObserveMultiplexer {
     // Allows all addHandleAndSendInitialAdds calls to return, once all preceding
     // adds have been processed. Does not block.
     ready() {
-        var self = this;
-        self._queue.queueTask(async () => {
-            if (self._ready())
+        this._queue.queueTask(async () => {
+            if (this._ready())
                 throw Error("can't make ObserveMultiplex ready twice!");
-            self._readyFuture.resolve();
-            self._readyFuture.isResolved = true;
+            this._readyFuture.resolve();
+            this._readyFuture.isResolved = true;
         });
     }
     // If trying to execute the query results in an error, call this. This is
@@ -138,7 +137,7 @@ class ObserveMultiplexer {
     _ready() {
         return this._readyFuture.isResolved;
     }
-    _applyCallback(callbackName, args) {
+    async _applyCallback(callbackName, args) {
         var self = this;
         self._queue.queueTask(async () => {
             // If we stopped in the meantime, do nothing.
@@ -179,7 +178,7 @@ class ObserveMultiplexer {
         if (!add)
             return;
         // note: docs may be an _IdMap or an OrderedDict
-        self._cache.docs.forEach(function (doc, id) {
+        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"]);

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

@@ -51,7 +51,7 @@ export declare class OplogObserveDriver {
     _beSteady(): void;
     _handleOplogEntryQuerying(op: any): void;
     _handleOplogEntrySteadyOrFetching(op: any): void;
-    _runInitialQuery(): void;
+    _runInitialQuery(): Promise<void>;
     _pollQuery(): void;
     _runQuery(options?: any): Promise<void>;
     _needToPollQuery(): void;

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

@@ -107,8 +107,8 @@ class OplogObserveDriver {
         self._stopHandles.push(self._mongoHandle._oplogHandle.onSkippedEntries(finishIfNeedToPollQuery(function () {
             self._needToPollQuery();
         })));
-        (0, observe_driver_utils_1.forEachTrigger)(self._cursorDescription, function (trigger) {
-            self._stopHandles.push(/*async*/ self._mongoHandle._oplogHandle.onOplogEntry(trigger, function (notification) {
+        (0, observe_driver_utils_1.forEachTrigger)(self._cursorDescription, async (trigger) => {
+            self._stopHandles.push(await self._mongoHandle._oplogHandle.onOplogEntry(trigger, function (notification) {
                 //Meteor._noYieldsAllowed(finishIfNeedToPollQuery(function () {
                 var op = notification.op;
                 if (notification.dropCollection || notification.dropDatabase) {
@@ -613,17 +613,17 @@ class OplogObserveDriver {
         //});
     }
     // Yields!
-    _runInitialQuery() {
+    async _runInitialQuery() {
         var self = this;
         if (self._stopped)
             throw new Error("oplog stopped surprisingly early");
-        self._runQuery({ initial: true }); // yields
+        await self._runQuery({ initial: true }); // yields
         if (self._stopped)
             return; // can happen on queryError
         // Allow observeChanges calls to return. (After this, it's possible for
         // stop() to be called.)
         self._multiplexer.ready();
-        self._doneQuerying(); // yields
+        await self._doneQuerying(); // yields
     }
     // In various circumstances, we may just want to stop processing the oplog and
     // re-run the initial query, just as if we were a PollingObserveDriver.

package/dist/meteor/mongo/synchronous-queue.d.ts

@@ -1,4 +1,4 @@
-declare type AsyncFunction = (...args: any[]) => Promise<any>;
+import { AsyncFunction } from "../types";
 export declare class _SynchronousQueue {
     private _taskHandles;
     private _runningOrRunScheduled;
@@ -11,4 +11,3 @@ export declare class _SynchronousQueue {
     _scheduleRun(): void;
     _run(): Promise<void>;
 }
-export {};

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

@@ -18,7 +18,7 @@ export declare class OrderedDict {
     remove(key: any): any;
     get(key: any): any;
     has(key: any): any;
-    forEach(iter: any, context?: any): void;
+    forEach(iter: (doc: any, key: string, index: number) => any, context?: any): void;
     first(): any;
     firstValue(): any;
     last(): any;

package/dist/meteor/types.d.ts

@@ -0,0 +1 @@
+export declare type AsyncFunction = (...args: any[]) => Promise<any>;

package/dist/meteor/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "mongodb-livedata-server",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "MongoDB live data server, extracted from Meteor, Fibers removed and converted to TypeScript",
   "main": "dist/livedata_server.js",
   "types": "dist/livedata_server.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc"
   },
   "keywords": [],
   "author": "Andrei Markeev",