mongodb-livedata-server 0.0.1

package/dist/meteor/ddp/stream_server.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamServer = void 0;
+const permessage_deflate_1 = __importDefault(require("permessage-deflate"));
+const sockjs_1 = __importDefault(require("sockjs"));
+const url_1 = __importDefault(require("url"));
+// By default, we use the permessage-deflate extension with default
+// configuration.
+class StreamServer {
+    constructor(httpServer) {
+        this.httpServer = httpServer;
+        this.registration_callbacks = [];
+        this.open_sockets = [];
+        // Because we are installing directly onto WebApp.httpServer instead of using
+        // WebApp.app, we have to process the path prefix ourselves.
+        this.prefix = '/sockjs';
+        //RoutePolicy.declare(this.prefix + '/', 'network');
+        // set up sockjs
+        const serverOptions = {
+            prefix: this.prefix,
+            log: function () { },
+            // this is the default, but we code it explicitly because we depend
+            // on it in stream_client:HEARTBEAT_TIMEOUT
+            heartbeat_delay: 45000,
+            // The default disconnect_delay is 5 seconds, but if the server ends up CPU
+            // bound for that much time, SockJS might not notice that the user has
+            // reconnected because the timer (of disconnect_delay ms) can fire before
+            // SockJS processes the new connection. Eventually we'll fix this by not
+            // combining CPU-heavy processing with SockJS termination (eg a proxy which
+            // converts to Unix sockets) but for now, raise the delay.
+            disconnect_delay: 60 * 1000,
+            // Set the USE_JSESSIONID environment variable to enable setting the
+            // JSESSIONID cookie. This is useful for setting up proxies with
+            // session affinity.
+            jsessionid: !!process.env.USE_JSESSIONID,
+            websocket: true,
+            faye_server_options: null
+        };
+        // If you know your server environment (eg, proxies) will prevent websockets
+        // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,
+        // browsers) will not waste time attempting to use them.
+        // (Your server will still have a /websocket endpoint.)
+        if (process.env.DISABLE_WEBSOCKETS) {
+            serverOptions.websocket = false;
+        }
+        else {
+            serverOptions.faye_server_options = {
+                extensions: [permessage_deflate_1.default.configure({})]
+            };
+        }
+        this.server = sockjs_1.default.createServer(serverOptions);
+        // Install the sockjs handlers, but we want to keep around our own particular
+        // request handler that adjusts idle timeouts while we have an outstanding
+        // request.  This compensates for the fact that sockjs removes all listeners
+        // for "request" to add its own.
+        httpServer.removeListener('request', _timeoutAdjustmentRequestCallback);
+        this.server.installHandlers(httpServer);
+        httpServer.addListener('request', _timeoutAdjustmentRequestCallback);
+        // Support the /websocket endpoint
+        this._redirectWebsocketEndpoint();
+        this.server.on('connection', (socket) => {
+            // sockjs sometimes passes us null instead of a socket object
+            // so we need to guard against that. see:
+            // https://github.com/sockjs/sockjs-node/issues/121
+            // https://github.com/meteor/meteor/issues/10468
+            if (!socket)
+                return;
+            // We want to make sure that if a client connects to us and does the initial
+            // Websocket handshake but never gets to the DDP handshake, that we
+            // eventually kill the socket.  Once the DDP handshake happens, DDP
+            // heartbeating will work. And before the Websocket handshake, the timeouts
+            // we set at the server level in webapp_server.js will work. But
+            // faye-websocket calls setTimeout(0) on any socket it takes over, so there
+            // is an "in between" state where this doesn't happen.  We work around this
+            // by explicitly setting the socket timeout to a relatively large time here,
+            // and setting it back to zero when we set up the heartbeat in
+            // livedata_server.js.
+            socket.setWebsocketTimeout = function (timeout) {
+                if ((socket.protocol === 'websocket' ||
+                    socket.protocol === 'websocket-raw')
+                    && socket._session.recv) {
+                    socket._session.recv.connection.setTimeout(timeout);
+                }
+            };
+            socket.setWebsocketTimeout(45 * 1000);
+            socket.send = (data) => {
+                socket.write(data);
+            };
+            socket.on('close', () => {
+                this.open_sockets = this.open_sockets.filter(s => s !== socket);
+            });
+            this.open_sockets.push(socket);
+            // only to send a message after connection on tests, useful for
+            // socket-stream-client/server-tests.js
+            if (process.env.TEST_METADATA && process.env.TEST_METADATA !== "{}") {
+                socket.send(JSON.stringify({ testMessageOnConnect: true }));
+            }
+            // call all our callbacks when we get a new socket. they will do the
+            // work of setting up handlers and such for specific messages.
+            for (const callback of this.registration_callbacks) {
+                callback(socket);
+            }
+        });
+    }
+    ;
+    // call my callback when a new socket connects.
+    // also call it for all current connections.
+    register(callback) {
+        var self = this;
+        self.registration_callbacks.push(callback);
+        for (const socket of self.all_sockets()) {
+            callback(socket);
+        }
+    }
+    // get a list of all sockets
+    all_sockets() {
+        return Object.values(this.open_sockets);
+    }
+    // Redirect /websocket to /sockjs/websocket in order to not expose
+    // sockjs to clients that want to use raw websockets
+    _redirectWebsocketEndpoint() {
+        var self = this;
+        // Unfortunately we can't use a connect middleware here since
+        // sockjs installs itself prior to all existing listeners
+        // (meaning prior to any connect middlewares) so we need to take
+        // an approach similar to overshadowListeners in
+        // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee
+        ['request', 'upgrade'].forEach((event) => {
+            var oldHttpServerListeners = this.httpServer.listeners(event).slice(0);
+            this.httpServer.removeAllListeners(event);
+            // request and upgrade have different arguments passed but
+            // we only care about the first one which is always request
+            var newListener = function (request /*, moreArguments */) {
+                // Store arguments for use within the closure below
+                var args = arguments;
+                // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while
+                // preserving query string.
+                var parsedUrl = url_1.default.parse(request.url);
+                if (parsedUrl.pathname === '/websocket' ||
+                    parsedUrl.pathname === '/websocket/') {
+                    parsedUrl.pathname = self.prefix + '/websocket';
+                    request.url = url_1.default.format(parsedUrl);
+                }
+                for (const oldListener of oldHttpServerListeners) {
+                    oldListener.apply(this.httpServer, args);
+                }
+            };
+            this.httpServer.addListener(event, newListener);
+        });
+    }
+}
+exports.StreamServer = StreamServer;
+const SHORT_SOCKET_TIMEOUT = 5 * 1000;
+const LONG_SOCKET_TIMEOUT = 120 * 1000;
+// When we have a request pending, we want the socket timeout to be long, to
+// give ourselves a while to serve it, and to allow sockjs long polls to
+// complete.  On the other hand, we want to close idle sockets relatively
+// quickly, so that we can shut down relatively promptly but cleanly, without
+// cutting off anyone's response.
+function _timeoutAdjustmentRequestCallback(req, res) {
+    // this is really just req.socket.setTimeout(LONG_SOCKET_TIMEOUT);
+    req.setTimeout(LONG_SOCKET_TIMEOUT);
+    // Insert our new finish listener to run BEFORE the existing one which removes
+    // the response from the socket.
+    var finishListeners = res.listeners('finish');
+    // XXX Apparently in Node 0.12 this event was called 'prefinish'.
+    // https://github.com/joyent/node/commit/7c9b6070
+    // But it has switched back to 'finish' in Node v4:
+    // https://github.com/nodejs/node/pull/1411
+    res.removeAllListeners('finish');
+    res.on('finish', function () {
+        res.setTimeout(SHORT_SOCKET_TIMEOUT);
+    });
+    for (const l of finishListeners) {
+        res.on('finish', l);
+    }
+}
+;

package/dist/meteor/ddp/subscription.js

@@ -0,0 +1,347 @@
+"use strict";
+// Ctor for a sub handle: the input to each publish function
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscription = void 0;
+const ejson_1 = require("../ejson/ejson");
+const main_1 = require("../random/main");
+const livedata_server_1 = require("./livedata_server");
+// Instance name is this because it's usually referred to as this inside a
+// publish
+/**
+ * @summary The server's side of a subscription
+ * @class Subscription
+ * @instanceName this
+ * @showInstanceName true
+ */
+class Subscription {
+    constructor(_session, _handler, _subscriptionId, _params = [], _name) {
+        this._session = _session;
+        this._handler = _handler;
+        this._subscriptionId = _subscriptionId;
+        this._params = _params;
+        this._name = _name;
+        // Has _deactivate been called?
+        this._deactivated = false;
+        // Stop callbacks to g/c this sub.  called w/ zero arguments.
+        this._stopCallbacks = [];
+        // The set of (collection, documentid) that this subscription has
+        // an opinion about.
+        this._documents = new Map();
+        // Remember if we are ready.
+        this._ready = false;
+        // For now, the id filter is going to default to
+        // the to/from DDP methods on MongoID, to
+        // specifically deal with mongo/minimongo ObjectIds.
+        // Later, you will be able to make this be "raw"
+        // if you want to publish a collection that you know
+        // just has strings for keys and no funny business, to
+        // a DDP consumer that isn't minimongo.
+        this._idFilter = {
+            idStringify: id => id /*MongoID.idStringify*/,
+            idParse: id => id /*MongoID.idParse*/
+        };
+        /**
+         * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.
+         * @locus Server
+         * @name  connection
+         * @memberOf Subscription
+         * @instance
+         */
+        this.connection = _session.connectionHandle; // public API object
+        // Only named subscriptions have IDs, but we need some sort of string
+        // internally to keep track of all subscriptions inside
+        // SessionDocumentViews. We use this subscriptionHandle for that.
+        if (this._subscriptionId) {
+            this._subscriptionHandle = `N${this._subscriptionId}`;
+        }
+        else {
+            this._subscriptionHandle = `U${main_1.Random.id()}`;
+        }
+        // Part of the public API: the user of this sub.
+        /**
+         * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.
+         * @locus Server
+         * @memberOf Subscription
+         * @name  userId
+         * @instance
+         */
+        this.userId = this._session.userId;
+    }
+    ;
+    _runHandler() {
+        // XXX should we unblock() here? Either before running the publish
+        // function, or before running _publishCursor.
+        //
+        // Right now, each publish function blocks all future publishes and
+        // methods waiting on data from Mongo (or whatever else the function
+        // blocks on). This probably slows page load in common cases.
+        let resultOrThenable = null;
+        const oldInvocation = livedata_server_1.DDP._CurrentPublicationInvocation;
+        try {
+            livedata_server_1.DDP._CurrentPublicationInvocation = this;
+            resultOrThenable = (0, livedata_server_1.maybeAuditArgumentChecks)(this._handler, this, (0, ejson_1.clone)(this._params), 
+            // It's OK that this would look weird for universal subscriptions,
+            // because they have no arguments so there can never be an
+            // audit-argument-checks failure.
+            "publisher '" + this._name + "'");
+        }
+        catch (e) {
+            this.error(e);
+            return;
+        }
+        finally {
+            livedata_server_1.DDP._CurrentPublicationInvocation = oldInvocation;
+        }
+        // Did the handler call this.error or this.stop?
+        if (this._isDeactivated())
+            return;
+        // Both conventional and async publish handler functions are supported.
+        // If an object is returned with a then() function, it is either a promise
+        // 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));
+        }
+        else {
+            this._publishHandlerResult(resultOrThenable);
+        }
+    }
+    _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
+        // _publishCursor method which starts observing the cursor and publishes the
+        // results. Note that _publishCursor does NOT call ready().
+        //
+        // XXX This uses an undocumented interface which only the Mongo cursor
+        // interface publishes. Should we make this interface public and encourage
+        // users to implement it themselves? Arguably, it's unnecessary; users can
+        // already write their own functions like
+        //   var publishMyReactiveThingy = function (name, handler) {
+        //     Meteor.publish(name, function () {
+        //       var reactiveThingy = handler();
+        //       reactiveThingy.publishMe();
+        //     });
+        //   };
+        var self = this;
+        var isCursor = function (c) {
+            return c && c._publishCursor;
+        };
+        if (isCursor(res)) {
+            try {
+                res._publishCursor(self);
+            }
+            catch (e) {
+                self.error(e);
+                return;
+            }
+            // _publishCursor only returns after the initial added callbacks have run.
+            // mark subscription as ready.
+            self.ready();
+        }
+        else if (Array.isArray(res)) {
+            // Check all the elements are cursors
+            if (!res.every(isCursor)) {
+                self.error(new Error("Publish function returned an array of non-Cursors"));
+                return;
+            }
+            // Find duplicate collection names
+            // XXX we should support overlapping cursors, but that would require the
+            // merge box to allow overlap within a subscription
+            var collectionNames = {};
+            for (var i = 0; i < res.length; ++i) {
+                var collectionName = res[i].cursorDescription.collectionName;
+                if (collectionNames.hasOwnProperty(collectionName)) {
+                    self.error(new Error("Publish function returned multiple cursors for collection " +
+                        collectionName));
+                    return;
+                }
+                collectionNames[collectionName] = true;
+            }
+            ;
+            try {
+                for (const cur of res) {
+                    cur._publishCursor(self);
+                }
+            }
+            catch (e) {
+                self.error(e);
+                return;
+            }
+            self.ready();
+        }
+        else if (res) {
+            // Truthy values other than cursors or arrays are probably a
+            // user mistake (possible returning a Mongo document via, say,
+            // `coll.findOne()`).
+            self.error(new Error("Publish function can only return a Cursor or "
+                + "an array of Cursors"));
+        }
+    }
+    // This calls all stop callbacks and prevents the handler from updating any
+    // SessionCollectionViews further. It's used when the user unsubscribes or
+    // disconnects, as well as during setUserId re-runs. It does *NOT* send
+    // removed messages for the published objects; if that is necessary, call
+    // _removeAllDocuments first.
+    _deactivate() {
+        var self = this;
+        if (self._deactivated)
+            return;
+        self._deactivated = true;
+        self._callStopCallbacks();
+        /*Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(
+            "livedata", "subscriptions", -1);*/
+    }
+    _callStopCallbacks() {
+        var self = this;
+        // Tell listeners, so they can clean up
+        var callbacks = self._stopCallbacks;
+        self._stopCallbacks = [];
+        for (const callback of callbacks) {
+            callback();
+        }
+    }
+    // Send remove messages for every document.
+    _removeAllDocuments() {
+        var self = this;
+        self._documents.forEach(function (collectionDocs, collectionName) {
+            collectionDocs.forEach(function (strId) {
+                self.removed(collectionName, self._idFilter.idParse(strId));
+            });
+        });
+    }
+    // Returns a new Subscription for the same session with the same
+    // initial creation parameters. This isn't a clone: it doesn't have
+    // the same _documents cache, stopped state or callbacks; may have a
+    // different _subscriptionHandle, and gets its userId from the
+    // session, not from this object.
+    _recreate() {
+        var self = this;
+        return new Subscription(self._session, self._handler, self._subscriptionId, self._params, self._name);
+    }
+    /**
+     * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).
+     * @locus Server
+     * @param {Error} error The error to pass to the client.
+     * @instance
+     * @memberOf Subscription
+     */
+    error(error) {
+        var self = this;
+        if (self._isDeactivated())
+            return;
+        self._session._stopSubscription(self._subscriptionId, error);
+    }
+    // Note that while our DDP client will notice that you've called stop() on the
+    // server (and clean up its _subscriptions table) we don't actually provide a
+    // mechanism for an app to notice this (the subscribe onError callback only
+    // triggers if there is an error).
+    /**
+     * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.
+     * @locus Server
+     * @instance
+     * @memberOf Subscription
+     */
+    stop() {
+        var self = this;
+        if (self._isDeactivated())
+            return;
+        self._session._stopSubscription(self._subscriptionId);
+    }
+    /**
+     * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {Function} func The callback function
+     */
+    onStop(func) {
+        var self = this;
+        if (self._isDeactivated())
+            func();
+        else
+            self._stopCallbacks.push(func);
+    }
+    // This returns true if the sub has been deactivated, *OR* if the session was
+    // destroyed but the deferred call to _deactivateAllSubscriptions hasn't
+    // happened yet.
+    _isDeactivated() {
+        var self = this;
+        return self._deactivated || self._session.inQueue === null;
+    }
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {String} collection The name of the collection that contains the new document.
+     * @param {String} id The new document's ID.
+     * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.
+     */
+    added(collectionName, id, fields) {
+        if (this._isDeactivated())
+            return;
+        id = this._idFilter.idStringify(id);
+        if (this._session.server.getPublicationStrategy(collectionName).doAccountingForCollection) {
+            let ids = this._documents.get(collectionName);
+            if (ids == null) {
+                ids = new Set();
+                this._documents.set(collectionName, ids);
+            }
+            ids.add(id);
+        }
+        this._session.added(this._subscriptionHandle, collectionName, id, fields);
+    }
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {String} collection The name of the collection that contains the changed document.
+     * @param {String} id The changed document's ID.
+     * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.
+     */
+    changed(collectionName, id, fields) {
+        if (this._isDeactivated())
+            return;
+        id = this._idFilter.idStringify(id);
+        this._session.changed(this._subscriptionHandle, collectionName, id, fields);
+    }
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     * @param {String} collection The name of the collection that the document has been removed from.
+     * @param {String} id The ID of the document that has been removed.
+     */
+    removed(collectionName, id) {
+        if (this._isDeactivated())
+            return;
+        id = this._idFilter.idStringify(id);
+        if (this._session.server.getPublicationStrategy(collectionName).doAccountingForCollection) {
+            // We don't bother to delete sets of things in a collection if the
+            // collection is empty.  It could break _removeAllDocuments.
+            this._documents.get(collectionName).delete(id);
+        }
+        this._session.removed(this._subscriptionHandle, collectionName, id);
+    }
+    /**
+     * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.
+     * @locus Server
+     * @memberOf Subscription
+     * @instance
+     */
+    ready() {
+        var self = this;
+        if (self._isDeactivated())
+            return;
+        if (!self._subscriptionId)
+            return; // Unnecessary but ignored for universal sub
+        if (!self._ready) {
+            self._session.sendReady([self._subscriptionId]);
+            self._ready = true;
+        }
+    }
+}
+exports.Subscription = Subscription;

package/dist/meteor/ddp/utils.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyDDP = exports.parseDDP = exports.SUPPORTED_DDP_VERSIONS = exports.last = exports.isEmpty = exports.keys = exports.slice = exports.hasOwn = void 0;
+const ejson_1 = require("../ejson/ejson");
+exports.hasOwn = Object.prototype.hasOwnProperty;
+exports.slice = Array.prototype.slice;
+function keys(obj) {
+    return Object.keys(Object(obj));
+}
+exports.keys = keys;
+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 (exports.hasOwn.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isEmpty = isEmpty;
+function last(array, n, guard) {
+    if (array == null) {
+        return;
+    }
+    if ((n == null) || guard) {
+        return array[array.length - 1];
+    }
+    return exports.slice.call(array, Math.max(array.length - n, 0));
+}
+exports.last = last;
+exports.SUPPORTED_DDP_VERSIONS = ['1', 'pre2', 'pre1'];
+function parseDDP(stringMessage) {
+    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 (exports.hasOwn.call(msg, 'cleared')) {
+        if (!exports.hasOwn.call(msg, 'fields')) {
+            msg.fields = {};
+        }
+        msg.cleared.forEach(clearKey => {
+            msg.fields[clearKey] = undefined;
+        });
+        delete msg.cleared;
+    }
+    ['fields', 'params', 'result'].forEach(field => {
+        if (exports.hasOwn.call(msg, field)) {
+            msg[field] = (0, ejson_1._adjustTypesFromJSONValue)(msg[field]);
+        }
+    });
+    return msg;
+}
+exports.parseDDP = parseDDP;
+;
+function stringifyDDP(msg) {
+    const copy = (0, ejson_1.clone)(msg);
+    // swizzle 'changed' messages from 'fields undefined' rep to 'fields
+    // and cleared' rep
+    if (exports.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 (exports.hasOwn.call(copy, field)) {
+            copy[field] = (0, ejson_1._adjustTypesToJSONValue)(copy[field]);
+        }
+    });
+    if (msg.id && typeof msg.id !== 'string') {
+        throw new Error("Message id is not a string");
+    }
+    return JSON.stringify(copy);
+}
+exports.stringifyDDP = stringifyDDP;
+;