mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/meteor/ddp/livedata_server.js

@@ -1,404 +1,404 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientSafeError = exports.ddpError = exports.maybeAuditArgumentChecks = exports.wrapInternalException = exports._calculateVersion = exports.DDPServer = exports.DDP = void 0;
-const method_invocation_1 = require("./method-invocation");
-const stream_server_1 = require("./stream_server");
-const session_1 = require("./session");
-const utils_1 = require("./utils");
-const random_stream_1 = require("./random-stream");
-const ejson_1 = require("../ejson/ejson");
-const hook_1 = require("../callback-hook/hook");
-exports.DDP = {};
-class DDPServer {
-    constructor(options = {}, httpServer) {
-        this.publish_handlers = {};
-        this.universal_publish_handlers = [];
-        this.method_handlers = {};
-        this._publicationStrategies = {};
-        this.sessions = new Map(); // map from id to session
-        var self = this;
-        // The default heartbeat interval is 30 seconds on the server and 35
-        // seconds on the client.  Since the client doesn't need to send a
-        // ping as long as it is receiving pings, this means that pings
-        // normally go from the server to the client.
-        //
-        // Note: Troposphere depends on the ability to mutate
-        // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.
-        self.options = Object.assign({ heartbeatInterval: 15000, heartbeatTimeout: 15000, 
-            // For testing, allow responding to pings to be disabled.
-            respondToPings: true, defaultPublicationStrategy: DDPServer.publicationStrategies.SERVER_MERGE }, options);
-        // Map of callbacks to call when a new connection comes in to the
-        // server and completes DDP version negotiation. Use an object instead
-        // of an array so we can safely remove one from the list while
-        // iterating over it.
-        self.onConnectionHook = new hook_1.Hook({
-            debugPrintExceptions: "onConnection callback"
-        });
-        // Map of callbacks to call when a new message comes in.
-        self.onMessageHook = new hook_1.Hook({
-            debugPrintExceptions: "onMessage callback"
-        });
-        self.stream_server = new stream_server_1.StreamServer(httpServer);
-        self.stream_server.register(function (socket) {
-            // socket implements the SockJSConnection interface
-            socket._meteorSession = null;
-            var sendError = function (reason, offendingMessage) {
-                var msg = { msg: 'error', reason, offendingMessage };
-                socket.send((0, utils_1.stringifyDDP)(msg));
-            };
-            socket.on('data', async function (raw_msg) {
-                try {
-                    try {
-                        var msg = (0, utils_1.parseDDP)(raw_msg);
-                    }
-                    catch (err) {
-                        sendError('Parse error');
-                        return;
-                    }
-                    if (msg === null || !msg.msg) {
-                        sendError('Bad request', msg);
-                        return;
-                    }
-                    if (msg.msg === 'connect') {
-                        if (socket._meteorSession) {
-                            sendError("Already connected", msg);
-                            return;
-                        }
-                        self._handleConnect(socket, msg);
-                        return;
-                    }
-                    if (!socket._meteorSession) {
-                        sendError('Must connect first', msg);
-                        return;
-                    }
-                    await socket._meteorSession.processMessage(msg);
-                }
-                catch (e) {
-                    // XXX print stack nicely
-                    console.log("Internal exception while processing message", msg, e);
-                }
-            });
-            socket.on('close', function () {
-                if (socket._meteorSession) {
-                    socket._meteorSession.close();
-                }
-            });
-        });
-    }
-    /**
-     * @summary Register a callback to be called when a new DDP connection is made to the server.
-     * @locus Server
-     * @param {function} callback The function to call when a new DDP connection is established.
-     * @memberOf Meteor
-     * @importFromPackage meteor
-     */
-    onConnection(fn) {
-        var self = this;
-        return self.onConnectionHook.register(fn);
-    }
-    /**
-     * @summary Set publication strategy for the given publication. Publications strategies are available from `DDPServer.publicationStrategies`. You call this method from `Meteor.server`, like `Meteor.server.setPublicationStrategy()`
-     * @locus Server
-     * @alias setPublicationStrategy
-     * @param publicationName {String}
-     * @param strategy {{useCollectionView: boolean, doAccountingForCollection: boolean}}
-     * @memberOf Meteor.server
-     * @importFromPackage meteor
-     */
-    setPublicationStrategy(publicationName, strategy) {
-        if (!Object.values(DDPServer.publicationStrategies).includes(strategy)) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientSafeError = exports.DDPServer = exports.DDP = void 0;
+exports._calculateVersion = _calculateVersion;
+exports.wrapInternalException = wrapInternalException;
+exports.maybeAuditArgumentChecks = maybeAuditArgumentChecks;
+exports.ddpError = ddpError;
+const method_invocation_1 = require("./method-invocation");
+const stream_server_1 = require("./stream_server");
+const session_1 = require("./session");
+const utils_1 = require("./utils");
+const random_stream_1 = require("./random-stream");
+const ejson_1 = require("../ejson/ejson");
+const hook_1 = require("../callback-hook/hook");
+exports.DDP = {};
+class DDPServer {
+    constructor(options = {}, httpServer) {
+        this.publish_handlers = {};
+        this.universal_publish_handlers = [];
+        this.method_handlers = {};
+        this._publicationStrategies = {};
+        this.sessions = new Map(); // map from id to session
+        var self = this;
+        // The default heartbeat interval is 30 seconds on the server and 35
+        // seconds on the client.  Since the client doesn't need to send a
+        // ping as long as it is receiving pings, this means that pings
+        // normally go from the server to the client.
+        //
+        // Note: Troposphere depends on the ability to mutate
+        // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.
+        self.options = Object.assign({ heartbeatInterval: 15000, heartbeatTimeout: 15000, 
+            // For testing, allow responding to pings to be disabled.
+            respondToPings: true, defaultPublicationStrategy: DDPServer.publicationStrategies.SERVER_MERGE }, options);
+        // Map of callbacks to call when a new connection comes in to the
+        // server and completes DDP version negotiation. Use an object instead
+        // of an array so we can safely remove one from the list while
+        // iterating over it.
+        self.onConnectionHook = new hook_1.Hook({
+            debugPrintExceptions: "onConnection callback"
+        });
+        // Map of callbacks to call when a new message comes in.
+        self.onMessageHook = new hook_1.Hook({
+            debugPrintExceptions: "onMessage callback"
+        });
+        self.stream_server = new stream_server_1.StreamServer(httpServer);
+        self.stream_server.register(function (socket) {
+            // socket implements the SockJSConnection interface
+            socket._meteorSession = null;
+            var sendError = function (reason, offendingMessage) {
+                var msg = { msg: 'error', reason, offendingMessage };
+                socket.send((0, utils_1.stringifyDDP)(msg));
+            };
+            socket.on('data', async function (raw_msg) {
+                try {
+                    try {
+                        var msg = (0, utils_1.parseDDP)(raw_msg);
+                    }
+                    catch (err) {
+                        sendError('Parse error');
+                        return;
+                    }
+                    if (msg === null || !msg.msg) {
+                        sendError('Bad request', msg);
+                        return;
+                    }
+                    if (msg.msg === 'connect') {
+                        if (socket._meteorSession) {
+                            sendError("Already connected", msg);
+                            return;
+                        }
+                        self._handleConnect(socket, msg);
+                        return;
+                    }
+                    if (!socket._meteorSession) {
+                        sendError('Must connect first', msg);
+                        return;
+                    }
+                    await socket._meteorSession.processMessage(msg);
+                }
+                catch (e) {
+                    // XXX print stack nicely
+                    console.log("Internal exception while processing message", msg, e);
+                }
+            });
+            socket.on('close', function () {
+                if (socket._meteorSession) {
+                    socket._meteorSession.close();
+                }
+            });
+        });
+    }
+    /**
+     * @summary Register a callback to be called when a new DDP connection is made to the server.
+     * @locus Server
+     * @param {function} callback The function to call when a new DDP connection is established.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     */
+    onConnection(fn) {
+        var self = this;
+        return self.onConnectionHook.register(fn);
+    }
+    /**
+     * @summary Set publication strategy for the given publication. Publications strategies are available from `DDPServer.publicationStrategies`. You call this method from `Meteor.server`, like `Meteor.server.setPublicationStrategy()`
+     * @locus Server
+     * @alias setPublicationStrategy
+     * @param publicationName {String}
+     * @param strategy {{useCollectionView: boolean, doAccountingForCollection: boolean}}
+     * @memberOf Meteor.server
+     * @importFromPackage meteor
+     */
+    setPublicationStrategy(publicationName, strategy) {
+        if (!Object.values(DDPServer.publicationStrategies).includes(strategy)) {
             throw new Error(`Invalid merge strategy: ${strategy} 
-        for collection ${publicationName}`);
-        }
-        this._publicationStrategies[publicationName] = strategy;
-    }
-    /**
-     * @summary Gets the publication strategy for the requested publication. You call this method from `Meteor.server`, like `Meteor.server.getPublicationStrategy()`
-     * @locus Server
-     * @alias getPublicationStrategy
-     * @param publicationName {String}
-     * @memberOf Meteor.server
-     * @importFromPackage meteor
-     * @return {{useCollectionView: boolean, doAccountingForCollection: boolean}}
-     */
-    getPublicationStrategy(publicationName) {
-        return this._publicationStrategies[publicationName]
-            || this.options.defaultPublicationStrategy;
-    }
-    /**
-     * @summary Register a callback to be called when a new DDP message is received.
-     * @locus Server
-     * @param {function} callback The function to call when a new DDP message is received.
-     * @memberOf Meteor
-     * @importFromPackage meteor
-     */
-    onMessage(fn) {
-        var self = this;
-        return self.onMessageHook.register(fn);
-    }
-    _handleConnect(socket, msg) {
-        var self = this;
-        // The connect message must specify a version and an array of supported
-        // versions, and it must claim to support what it is proposing.
-        if (!(typeof (msg.version) === 'string' &&
-            Array.isArray(msg.support) &&
-            msg.support.every(s => typeof s === "string") &&
-            msg.support.includes(msg.version))) {
-            socket.send((0, utils_1.stringifyDDP)({
-                msg: 'failed',
-                version: utils_1.SUPPORTED_DDP_VERSIONS[0]
-            }));
-            socket.close();
-            return;
-        }
-        // In the future, handle session resumption: something like:
-        //  socket._meteorSession = self.sessions[msg.session]
-        var version = _calculateVersion(msg.support, utils_1.SUPPORTED_DDP_VERSIONS);
-        if (msg.version !== version) {
-            // The best version to use (according to the client's stated preferences)
-            // is not the one the client is trying to use. Inform them about the best
-            // version to use.
-            socket.send((0, utils_1.stringifyDDP)({ msg: 'failed', version: version }));
-            socket.close();
-            return;
-        }
-        // Yay, version matches! Create a new session.
-        // Note: Troposphere depends on the ability to mutate
-        // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.
-        socket._meteorSession = new session_1.DDPSession(self, version, socket, self.options);
-        self.sessions.set(socket._meteorSession.id, socket._meteorSession);
-        self.onConnectionHook.each(function (callback) {
-            if (socket._meteorSession)
-                callback(socket._meteorSession.connectionHandle);
-            return true;
-        });
-    }
-    /**
-     * Register a publish handler function.
-     *
-     * @param name {String} identifier for query
-     * @param handler {Function} publish handler
-     *
-     * Server will call handler function on each new subscription,
-     * either when receiving DDP sub message for a named subscription, or on
-     * DDP connect for a universal subscription.
-     *
-     * If name is null, this will be a subscription that is
-     * automatically established and permanently on for all connected
-     * client, instead of a subscription that can be turned on and off
-     * with subscribe().
-     *
-     */
-    /**
-     * @summary Publish a record set.
-     * @memberOf Meteor
-     * @importFromPackage meteor
-     * @locus Server
-     * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.
-     * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.
-     */
-    publish(name, handler) {
-        var self = this;
-        if (typeof name === "string") {
-            if (name in self.publish_handlers) {
-                console.log("Ignoring duplicate publish named '" + name + "'");
-                return;
-            }
-            self.publish_handlers[name] = handler;
-        }
-        else if (name == null) {
-            self.universal_publish_handlers.push(handler);
-            // Spin up the new publisher on any existing session too. Run each
-            // session's subscription in a new Fiber, so that there's no change for
-            // self.sessions to change while we're running this loop.
-            self.sessions.forEach(function (session) {
-                if (!session._dontStartNewUniversalSubs) {
-                    session._startSubscription(handler);
-                }
-            });
-        }
-        else {
-            for (const [key, value] of Object.entries(name)) {
-                self.publish(key, value);
-            }
-        }
-    }
-    _removeSession(session) {
-        this.sessions.delete(session.id);
-    }
-    /**
-     * @summary Defines functions that can be invoked over the network by clients.
-     * @locus Anywhere
-     * @param {Object} methods Dictionary whose keys are method names and values are functions.
-     * @memberOf Meteor
-     * @importFromPackage meteor
-     */
-    methods(methods) {
-        var self = this;
-        for (const [name, func] of Object.entries(methods)) {
-            if (typeof func !== 'function')
-                throw new Error("Method '" + name + "' must be a function");
-            if (self.method_handlers[name])
-                throw new Error("A method named '" + name + "' is already defined");
-            self.method_handlers[name] = func;
-        }
-    }
-    // A version of the call method that always returns a Promise.
-    callAsync(name, ...args) {
-        return this.applyAsync(name, args);
-    }
-    // @param options {Optional Object}
-    applyAsync(name, args) {
-        // Run the handler
-        var handler = this.method_handlers[name];
-        if (!handler) {
-            return Promise.reject(ddpError(404, `Method '${name}' not found`));
-        }
-        // If this is a method call from within another method or publish function,
-        // get the user state from the outer method or publish function, otherwise
-        // don't allow setUserId to be called
-        var userId = null;
-        var setUserId = function () {
-            throw new Error("Can't call setUserId on a server initiated method call");
-        };
-        var connection = null;
-        var currentMethodInvocation = exports.DDP._CurrentMethodInvocation;
-        var currentPublicationInvocation = exports.DDP._CurrentPublicationInvocation;
-        var randomSeed = null;
-        if (currentMethodInvocation) {
-            userId = currentMethodInvocation.userId;
-            setUserId = function (userId) {
-                currentMethodInvocation.setUserId(userId);
-            };
-            connection = currentMethodInvocation.connection;
-            randomSeed = (0, random_stream_1.makeRpcSeed)(currentMethodInvocation, name);
-        }
-        else if (currentPublicationInvocation) {
-            userId = currentPublicationInvocation.userId;
-            setUserId = function (userId) {
-                currentPublicationInvocation._session._setUserId(userId);
-            };
-            connection = currentPublicationInvocation.connection;
-        }
-        var invocation = new method_invocation_1.MethodInvocation({
-            isSimulation: false,
-            userId,
-            setUserId,
-            connection,
-            randomSeed
-        });
-        return new Promise(resolve => {
-            const oldInvocation = exports.DDP._CurrentMethodInvocation;
-            try {
-                exports.DDP._CurrentMethodInvocation = invocation;
-                const result = maybeAuditArgumentChecks(handler, invocation, (0, ejson_1.clone)(args), "internal call to '" + name + "'");
-                resolve(result);
-            }
-            finally {
-                exports.DDP._CurrentMethodInvocation = oldInvocation;
-            }
-        }).then(ejson_1.clone);
-    }
-    _urlForSession(sessionId) {
-        var self = this;
-        var session = self.sessions.get(sessionId);
-        if (session)
-            return session._socketUrl;
-        else
-            return null;
-    }
-}
-exports.DDPServer = DDPServer;
-// Publication strategies define how we handle data from published cursors at the collection level
-// This allows someone to:
-// - Choose a trade-off between client-server bandwidth and server memory usage
-// - Implement special (non-mongo) collections like volatile message queues
-DDPServer.publicationStrategies = {
-    // SERVER_MERGE is the default strategy.
-    // When using this strategy, the server maintains a copy of all data a connection is subscribed to.
-    // This allows us to only send deltas over multiple publications.
-    SERVER_MERGE: {
-        useCollectionView: true,
-        doAccountingForCollection: true,
-    },
-    // The NO_MERGE_NO_HISTORY strategy results in the server sending all publication data
-    // directly to the client. It does not remember what it has previously sent
-    // to it will not trigger removed messages when a subscription is stopped.
-    // This should only be chosen for special use cases like send-and-forget queues.
-    NO_MERGE_NO_HISTORY: {
-        useCollectionView: false,
-        doAccountingForCollection: false,
-    },
-    // NO_MERGE is similar to NO_MERGE_NO_HISTORY but the server will remember the IDs it has
-    // sent to the client so it can remove them when a subscription is stopped.
-    // This strategy can be used when a collection is only used in a single publication.
-    NO_MERGE: {
-        useCollectionView: false,
-        doAccountingForCollection: true,
-    }
-};
-function _calculateVersion(clientSupportedVersions, serverSupportedVersions) {
-    var correctVersion = clientSupportedVersions.find(version => serverSupportedVersions.includes(version));
-    if (!correctVersion) {
-        correctVersion = serverSupportedVersions[0];
-    }
-    return correctVersion;
-}
-exports._calculateVersion = _calculateVersion;
-;
-// "blind" exceptions other than those that were deliberately thrown to signal
-// errors to the client
-function wrapInternalException(exception, context) {
-    if (!exception)
-        return exception;
-    // To allow packages to throw errors intended for the client but not have to
-    // depend on the Meteor.Error class, `isClientSafe` can be set to true on any
-    // error before it is thrown.
-    if (exception.isClientSafe) {
-        if (!(exception instanceof ClientSafeError)) {
-            const originalMessage = exception.message;
-            exception = ddpError(exception.error, exception.reason, exception.details);
-            exception.message = originalMessage;
-        }
-        return exception;
-    }
-    // Did the error contain more details that could have been useful if caught in
-    // server code (or if thrown from non-client-originated code), but also
-    // provided a "sanitized" version with more context than 500 Internal server
-    // error? Use that.
-    if (exception.sanitizedError) {
-        if (exception.sanitizedError.isClientSafe)
-            return exception.sanitizedError;
-    }
-    console.error("Error " + context + ":", exception);
-    return ddpError(500, "Internal server error");
-}
-exports.wrapInternalException = wrapInternalException;
-;
-// Audit argument checks, if the audit-argument-checks package exists (it is a
-// weak dependency of this package).
-function maybeAuditArgumentChecks(f, context, args, description) {
-    args = args || [];
-    /*if (Package['audit-argument-checks']) {
-        return Match._failIfArgumentsAreNotAllChecked(
-            f, context, args, description);
-    }*/
-    return f.apply(context, args);
-}
-exports.maybeAuditArgumentChecks = maybeAuditArgumentChecks;
-;
-function ddpError(error, reason, details) {
-    return { isClientSafe: true, error, reason, message: (reason ? reason + " " : "") + "[" + error + "]", errorType: "Meteor.Error" };
-}
-exports.ddpError = ddpError;
-class ClientSafeError extends Error {
-    constructor(error, reason, details) {
-        super((reason ? reason + " " : "") + "[" + error + "]");
-        this.error = error;
-        this.reason = reason;
-        this.details = details;
-        this.isClientSafe = true;
-        this.errorType = "Meteor.Error";
-    }
-}
-exports.ClientSafeError = ClientSafeError;
+        for collection ${publicationName}`);
+        }
+        this._publicationStrategies[publicationName] = strategy;
+    }
+    /**
+     * @summary Gets the publication strategy for the requested publication. You call this method from `Meteor.server`, like `Meteor.server.getPublicationStrategy()`
+     * @locus Server
+     * @alias getPublicationStrategy
+     * @param publicationName {String}
+     * @memberOf Meteor.server
+     * @importFromPackage meteor
+     * @return {{useCollectionView: boolean, doAccountingForCollection: boolean}}
+     */
+    getPublicationStrategy(publicationName) {
+        return this._publicationStrategies[publicationName]
+            || this.options.defaultPublicationStrategy;
+    }
+    /**
+     * @summary Register a callback to be called when a new DDP message is received.
+     * @locus Server
+     * @param {function} callback The function to call when a new DDP message is received.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     */
+    onMessage(fn) {
+        var self = this;
+        return self.onMessageHook.register(fn);
+    }
+    _handleConnect(socket, msg) {
+        var self = this;
+        // The connect message must specify a version and an array of supported
+        // versions, and it must claim to support what it is proposing.
+        if (!(typeof (msg.version) === 'string' &&
+            Array.isArray(msg.support) &&
+            msg.support.every(s => typeof s === "string") &&
+            msg.support.includes(msg.version))) {
+            socket.send((0, utils_1.stringifyDDP)({
+                msg: 'failed',
+                version: utils_1.SUPPORTED_DDP_VERSIONS[0]
+            }));
+            socket.close();
+            return;
+        }
+        // In the future, handle session resumption: something like:
+        //  socket._meteorSession = self.sessions[msg.session]
+        var version = _calculateVersion(msg.support, utils_1.SUPPORTED_DDP_VERSIONS);
+        if (msg.version !== version) {
+            // The best version to use (according to the client's stated preferences)
+            // is not the one the client is trying to use. Inform them about the best
+            // version to use.
+            socket.send((0, utils_1.stringifyDDP)({ msg: 'failed', version: version }));
+            socket.close();
+            return;
+        }
+        // Yay, version matches! Create a new session.
+        // Note: Troposphere depends on the ability to mutate
+        // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.
+        socket._meteorSession = new session_1.DDPSession(self, version, socket, self.options);
+        self.sessions.set(socket._meteorSession.id, socket._meteorSession);
+        self.onConnectionHook.each(function (callback) {
+            if (socket._meteorSession)
+                callback(socket._meteorSession.connectionHandle);
+            return true;
+        });
+    }
+    /**
+     * Register a publish handler function.
+     *
+     * @param name {String} identifier for query
+     * @param handler {Function} publish handler
+     *
+     * Server will call handler function on each new subscription,
+     * either when receiving DDP sub message for a named subscription, or on
+     * DDP connect for a universal subscription.
+     *
+     * If name is null, this will be a subscription that is
+     * automatically established and permanently on for all connected
+     * client, instead of a subscription that can be turned on and off
+     * with subscribe().
+     *
+     */
+    /**
+     * @summary Publish a record set.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     * @locus Server
+     * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.
+     * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.
+     */
+    publish(name, handler) {
+        var self = this;
+        if (typeof name === "string") {
+            if (name in self.publish_handlers) {
+                console.log("Ignoring duplicate publish named '" + name + "'");
+                return;
+            }
+            self.publish_handlers[name] = handler;
+        }
+        else if (name == null) {
+            self.universal_publish_handlers.push(handler);
+            // Spin up the new publisher on any existing session too. Run each
+            // session's subscription in a new Fiber, so that there's no change for
+            // self.sessions to change while we're running this loop.
+            self.sessions.forEach(function (session) {
+                if (!session._dontStartNewUniversalSubs) {
+                    session._startSubscription(handler);
+                }
+            });
+        }
+        else {
+            for (const [key, value] of Object.entries(name)) {
+                self.publish(key, value);
+            }
+        }
+    }
+    _removeSession(session) {
+        this.sessions.delete(session.id);
+    }
+    /**
+     * @summary Defines functions that can be invoked over the network by clients.
+     * @locus Anywhere
+     * @param {Object} methods Dictionary whose keys are method names and values are functions.
+     * @memberOf Meteor
+     * @importFromPackage meteor
+     */
+    methods(methods) {
+        var self = this;
+        for (const [name, func] of Object.entries(methods)) {
+            if (typeof func !== 'function')
+                throw new Error("Method '" + name + "' must be a function");
+            if (self.method_handlers[name])
+                throw new Error("A method named '" + name + "' is already defined");
+            self.method_handlers[name] = func;
+        }
+    }
+    // A version of the call method that always returns a Promise.
+    callAsync(name, ...args) {
+        return this.applyAsync(name, args);
+    }
+    // @param options {Optional Object}
+    applyAsync(name, args) {
+        // Run the handler
+        var handler = this.method_handlers[name];
+        if (!handler) {
+            return Promise.reject(ddpError(404, `Method '${name}' not found`));
+        }
+        // If this is a method call from within another method or publish function,
+        // get the user state from the outer method or publish function, otherwise
+        // don't allow setUserId to be called
+        var userId = null;
+        var setUserId = function () {
+            throw new Error("Can't call setUserId on a server initiated method call");
+        };
+        var connection = null;
+        var currentMethodInvocation = exports.DDP._CurrentMethodInvocation;
+        var currentPublicationInvocation = exports.DDP._CurrentPublicationInvocation;
+        var randomSeed = null;
+        if (currentMethodInvocation) {
+            userId = currentMethodInvocation.userId;
+            setUserId = function (userId) {
+                currentMethodInvocation.setUserId(userId);
+            };
+            connection = currentMethodInvocation.connection;
+            randomSeed = (0, random_stream_1.makeRpcSeed)(currentMethodInvocation, name);
+        }
+        else if (currentPublicationInvocation) {
+            userId = currentPublicationInvocation.userId;
+            setUserId = function (userId) {
+                currentPublicationInvocation._session._setUserId(userId);
+            };
+            connection = currentPublicationInvocation.connection;
+        }
+        var invocation = new method_invocation_1.MethodInvocation({
+            isSimulation: false,
+            userId,
+            setUserId,
+            connection,
+            randomSeed
+        });
+        return new Promise(resolve => {
+            const oldInvocation = exports.DDP._CurrentMethodInvocation;
+            try {
+                exports.DDP._CurrentMethodInvocation = invocation;
+                const result = maybeAuditArgumentChecks(handler, invocation, (0, ejson_1.clone)(args), "internal call to '" + name + "'");
+                resolve(result);
+            }
+            finally {
+                exports.DDP._CurrentMethodInvocation = oldInvocation;
+            }
+        }).then(ejson_1.clone);
+    }
+    _urlForSession(sessionId) {
+        var self = this;
+        var session = self.sessions.get(sessionId);
+        if (session)
+            return session._socketUrl;
+        else
+            return null;
+    }
+}
+exports.DDPServer = DDPServer;
+// Publication strategies define how we handle data from published cursors at the collection level
+// This allows someone to:
+// - Choose a trade-off between client-server bandwidth and server memory usage
+// - Implement special (non-mongo) collections like volatile message queues
+DDPServer.publicationStrategies = {
+    // SERVER_MERGE is the default strategy.
+    // When using this strategy, the server maintains a copy of all data a connection is subscribed to.
+    // This allows us to only send deltas over multiple publications.
+    SERVER_MERGE: {
+        useCollectionView: true,
+        doAccountingForCollection: true,
+    },
+    // The NO_MERGE_NO_HISTORY strategy results in the server sending all publication data
+    // directly to the client. It does not remember what it has previously sent
+    // to it will not trigger removed messages when a subscription is stopped.
+    // This should only be chosen for special use cases like send-and-forget queues.
+    NO_MERGE_NO_HISTORY: {
+        useCollectionView: false,
+        doAccountingForCollection: false,
+    },
+    // NO_MERGE is similar to NO_MERGE_NO_HISTORY but the server will remember the IDs it has
+    // sent to the client so it can remove them when a subscription is stopped.
+    // This strategy can be used when a collection is only used in a single publication.
+    NO_MERGE: {
+        useCollectionView: false,
+        doAccountingForCollection: true,
+    }
+};
+function _calculateVersion(clientSupportedVersions, serverSupportedVersions) {
+    var correctVersion = clientSupportedVersions.find(version => serverSupportedVersions.includes(version));
+    if (!correctVersion) {
+        correctVersion = serverSupportedVersions[0];
+    }
+    return correctVersion;
+}
+;
+// "blind" exceptions other than those that were deliberately thrown to signal
+// errors to the client
+function wrapInternalException(exception, context) {
+    if (!exception)
+        return exception;
+    // To allow packages to throw errors intended for the client but not have to
+    // depend on the Meteor.Error class, `isClientSafe` can be set to true on any
+    // error before it is thrown.
+    if (exception.isClientSafe) {
+        if (!(exception instanceof ClientSafeError)) {
+            const originalMessage = exception.message;
+            exception = ddpError(exception.error, exception.reason, exception.details);
+            exception.message = originalMessage;
+        }
+        return exception;
+    }
+    // Did the error contain more details that could have been useful if caught in
+    // server code (or if thrown from non-client-originated code), but also
+    // provided a "sanitized" version with more context than 500 Internal server
+    // error? Use that.
+    if (exception.sanitizedError) {
+        if (exception.sanitizedError.isClientSafe)
+            return exception.sanitizedError;
+    }
+    console.error("Error " + context + ":", exception);
+    return ddpError(500, "Internal server error");
+}
+;
+// Audit argument checks, if the audit-argument-checks package exists (it is a
+// weak dependency of this package).
+function maybeAuditArgumentChecks(f, context, args, description) {
+    args = args || [];
+    /*if (Package['audit-argument-checks']) {
+        return Match._failIfArgumentsAreNotAllChecked(
+            f, context, args, description);
+    }*/
+    return f.apply(context, args);
+}
+;
+function ddpError(error, reason, details) {
+    return { isClientSafe: true, error, reason, message: (reason ? reason + " " : "") + "[" + error + "]", errorType: "Meteor.Error" };
+}
+class ClientSafeError extends Error {
+    constructor(error, reason, details) {
+        super((reason ? reason + " " : "") + "[" + error + "]");
+        this.error = error;
+        this.reason = reason;
+        this.details = details;
+        this.isClientSafe = true;
+        this.errorType = "Meteor.Error";
+    }
+}
+exports.ClientSafeError = ClientSafeError;