mongodb-livedata-server 0.0.4 → 0.0.6

package/meteor/ddp/livedata_server.ts

@@ -1,474 +0,0 @@
-import { MethodInvocation } from "./method-invocation";
-import { StreamServer, StreamServerSocket } from "./stream_server";
-import { DDPSession, SessionConnectionHandle } from "./session";
-import { Server } from "http";
-import { parseDDP, stringifyDDP, SUPPORTED_DDP_VERSIONS } from "./utils";
-import { makeRpcSeed } from "./random-stream";
-import { clone } from "../ejson/ejson";
-import { Hook } from "../callback-hook/hook";
-import { Subscription } from "./subscription";
-
-export const DDP: {
-    _CurrentPublicationInvocation: Subscription,
-    _CurrentMethodInvocation: MethodInvocation
-} = {} as any;
-
-// This file contains classes:
-// * Session - The server's connection to a single DDP client
-// * Subscription - A single subscription for a single client
-// * Server - An entire server that may talk to > 1 client. A DDP endpoint.
-//
-// Session and Subscription are file scope. For now, until we freeze
-// the interface, Server is package scope (in the future it should be
-// exported).
-
-
-/******************************************************************************/
-/* Server                                                                     */
-/******************************************************************************/
-
-interface PublicationStrategy {
-    useCollectionView: boolean;
-    doAccountingForCollection: boolean;
-}
-
-export class DDPServer {
-    private options: {
-        heartbeatInterval: number;
-        heartbeatTimeout: number;
-        // For testing, allow responding to pings to be disabled.
-        respondToPings: boolean;
-        defaultPublicationStrategy: PublicationStrategy;
-    };
-
-    private onConnectionHook: Hook;
-    private onMessageHook: Hook;
-
-    private publish_handlers: Record<string, any> = {};
-    private universal_publish_handlers = [];
-    private method_handlers = {};
-    private _publicationStrategies = {};
-    private sessions = new Map<string, DDPSession>(); // map from id to session
-    private stream_server: StreamServer;
-
-    constructor (options = {}, httpServer: Server) {
-        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 = {
-            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({
-            debugPrintExceptions: "onConnection callback"
-        });
-
-        // Map of callbacks to call when a new message comes in.
-        self.onMessageHook = new Hook({
-            debugPrintExceptions: "onMessage callback"
-        });
-
-
-        self.stream_server = new 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(stringifyDDP(msg));
-            };
-
-            socket.on('data', async function (raw_msg) {
-                try {
-                    try {
-                        var msg = 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();
-                }
-            });
-        });
-    }
-
-    // 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
-    public static 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,
-        }
-    }
-
-    /**
-     * @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: (conn: SessionConnectionHandle) => void) {
-        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: string, strategy: PublicationStrategy) {
-        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: string): PublicationStrategy {
-        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: StreamServerSocket, msg: any) {
-        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(stringifyDDP({
-                msg: 'failed',
-                version: 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, 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(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 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: string | Record<string, (this: MethodInvocation, ...args: any[]) => Promise<any>> | null, handler?: (this: MethodInvocation, ...args: any[]) => Promise<any>) {
-        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: DDPSession) {
-        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: Record<string, (this: MethodInvocation, ...args: any[]) => Promise<any>>) {
-        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: string, ...args: any[]) {
-        return this.applyAsync(name, args);
-    }
-
-    // @param options {Optional Object}
-    applyAsync(name: string, args: any[]) {
-        // 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: (userId: string) => void = function () {
-            throw new Error("Can't call setUserId on a server initiated method call");
-        };
-        var connection = null;
-        var currentMethodInvocation = DDP._CurrentMethodInvocation;
-        var currentPublicationInvocation = DDP._CurrentPublicationInvocation;
-        var randomSeed = null;
-        if (currentMethodInvocation) {
-            userId = currentMethodInvocation.userId;
-            setUserId = function (userId) {
-                currentMethodInvocation.setUserId(userId);
-            };
-            connection = currentMethodInvocation.connection;
-            randomSeed = makeRpcSeed(currentMethodInvocation, name);
-        } else if (currentPublicationInvocation) {
-            userId = currentPublicationInvocation.userId;
-            setUserId = function (userId) {
-                currentPublicationInvocation._session._setUserId(userId);
-            };
-            connection = currentPublicationInvocation.connection;
-        }
-
-        var invocation = new MethodInvocation({
-            isSimulation: false,
-            userId,
-            setUserId,
-            connection,
-            randomSeed
-        });
-
-        return new Promise(resolve => {
-            const oldInvocation = DDP._CurrentMethodInvocation;
-            try {
-                DDP._CurrentMethodInvocation = invocation;
-                const result = maybeAuditArgumentChecks(handler, invocation, clone(args), "internal call to '" + name + "'");
-                resolve(result);
-            } finally {
-                DDP._CurrentMethodInvocation = oldInvocation;
-            }
-        }).then(clone);
-    }
-
-    _urlForSession(sessionId) {
-        var self = this;
-        var session = self.sessions.get(sessionId);
-        if (session)
-            return session._socketUrl;
-        else
-            return null;
-    }
-}
-
-export 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
-export 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;
-    }
-
-    return ddpError(500, "Internal server error");
-};
-
-
-// Audit argument checks, if the audit-argument-checks package exists (it is a
-// weak dependency of this package).
-export function maybeAuditArgumentChecks(f: Function, context: any, args: any[] | null, description: string) {
-    args = args || [];
-    /*if (Package['audit-argument-checks']) {
-        return Match._failIfArgumentsAreNotAllChecked(
-            f, context, args, description);
-    }*/
-    return f.apply(context, args);
-};
-
-export function ddpError(error: string | number, reason?: string, details?: string) {
-    return { isClientSafe: true, error, reason, message: (reason ? reason + " " : "") + "[" + error + "]", errorType: "Meteor.Error" };
-}
-
-export class ClientSafeError extends Error {
-    constructor(public error: string | number, public reason?: string, public details?: string) {
-        super((reason ? reason + " " : "") + "[" + error + "]");
-    }
-    public isClientSafe = true;
-    public errorType = "Meteor.Error";
-}

package/meteor/ddp/method-invocation.ts

@@ -1,86 +0,0 @@
-// Instance name is this because it is usually referred to as this inside a
-// method definition
-/**
- * @summary The state for a single invocation of a method, referenced by this
- * inside a method definition.
- * @param {Object} options
- * @instanceName this
- * @showInstanceName true
- */
-export class MethodInvocation {
-    public userId: string;
-    public connection: any;
-
-    private isSimulation: boolean;
-    private _isFromCallAsync: boolean;
-    private _setUserId: Function;
-    private randomSeed: number;
-    private randomStream: any;
-
-    constructor(options) {
-      // true if we're running not the actual method, but a stub (that is,
-      // if we're on a client (which may be a browser, or in the future a
-      // server connecting to another server) and presently running a
-      // simulation of a server-side method for latency compensation
-      // purposes). not currently true except in a client such as a browser,
-      // since there's usually no point in running stubs unless you have a
-      // zero-latency connection to the user.
-  
-      /**
-       * @summary Access inside a method invocation.  Boolean value, true if this invocation is a stub.
-       * @locus Anywhere
-       * @name  isSimulation
-       * @memberOf DDPCommon.MethodInvocation
-       * @instance
-       * @type {Boolean}
-       */
-      this.isSimulation = options.isSimulation;
-  
-      // used to know when the function apply was called by callAsync
-      this._isFromCallAsync = options.isFromCallAsync;
-  
-      // current user id
-  
-      /**
-       * @summary The id of the user that made this method call, or `null` if no user was logged in.
-       * @locus Anywhere
-       * @name  userId
-       * @memberOf DDPCommon.MethodInvocation
-       * @instance
-       */
-      this.userId = options.userId;
-  
-      // sets current user id in all appropriate server contexts and
-      // reruns subscriptions
-      this._setUserId = options.setUserId || function () {};
-  
-      // On the server, the connection this method call came in on.
-  
-      /**
-       * @summary Access inside a method invocation. The [connection](#meteor_onconnection) that this method was received on. `null` if the method is not associated with a connection, eg. a server initiated method call. Calls to methods made from a server method which was in turn initiated from the client share the same `connection`.
-       * @locus Server
-       * @name  connection
-       * @memberOf DDPCommon.MethodInvocation
-       * @instance
-       */
-      this.connection = options.connection;
-  
-      // The seed for randomStream value generation
-      this.randomSeed = options.randomSeed;
-  
-      // This is set by RandomStream.get; and holds the random stream state
-      this.randomStream = null;
-    }
-
-    /**
-     * @summary Set the logged in user.
-     * @locus Server
-     * @memberOf DDPCommon.MethodInvocation
-     * @instance
-     * @param {String | null} userId The value that should be returned by `userId` on this connection.
-     */
-    setUserId(userId: string | null) {
-      this.userId = userId;
-      this._setUserId(userId);
-    }
-  };

package/meteor/ddp/random-stream.ts

@@ -1,102 +0,0 @@
-// RandomStream allows for generation of pseudo-random values, from a seed.
-//
-// We use this for consistent 'random' numbers across the client and server.
-// We want to generate probably-unique IDs on the client, and we ideally want
-// the server to generate the same IDs when it executes the method.
-//
-// For generated values to be the same, we must seed ourselves the same way,
-// and we must keep track of the current state of our pseudo-random generators.
-// We call this state the scope. By default, we use the current DDP method
-// invocation as our scope.  DDP now allows the client to specify a randomSeed.
-// If a randomSeed is provided it will be used to seed our random sequences.
-// In this way, client and server method calls will generate the same values.
-//
-// We expose multiple named streams; each stream is independent
-// and is seeded differently (but predictably from the name).
-// By using multiple streams, we support reordering of requests,
-// as long as they occur on different streams.
-//
-// @param options {Optional Object}
-//   seed: Array or value - Seed value(s) for the generator.
-//                          If an array, will be used as-is
-//                          If a value, will be converted to a single-value array
-
-import { Random } from "../random/main";
-
-//                          If omitted, a random array will be used as the seed.
-export class RandomStream {
-    private seed: Function[];
-    private sequences: Object;
-
-    constructor(options) {
-        this.seed = [].concat(options.seed || randomToken());
-        this.sequences = Object.create(null);
-    }
-
-    // Get a random sequence with the specified name, creating it if does not exist.
-    // New sequences are seeded with the seed concatenated with the name.
-    // By passing a seed into Random.create, we use the Alea generator.
-    _sequence(name) {
-        var self = this;
-
-        var sequence = self.sequences[name] || null;
-        if (sequence === null) {
-            var sequenceSeed = self.seed.concat(name);
-            for (var i = 0; i < sequenceSeed.length; i++) {
-                if (typeof sequenceSeed[i] === "function") {
-                    sequenceSeed[i] = sequenceSeed[i]();
-                }
-            }
-            self.sequences[name] = sequence = Random.createWithSeeds.apply(null, sequenceSeed);
-        }
-        return sequence;
-    }
-
-    // Returns the random stream with the specified name, in the specified
-    // scope. If a scope is passed, then we use that to seed a (not
-    // cryptographically secure) PRNG using the fast Alea algorithm.  If
-    // scope is null (or otherwise falsey) then we use a generated seed.
-    //
-    // However, scope will normally be the current DDP method invocation,
-    // so we'll use the stream with the specified name, and we should get
-    // consistent values on the client and server sides of a method call.
-    static get(scope, name) {
-        if (!name) {
-            name = "default";
-        }
-        if (!scope) {
-            // There was no scope passed in; the sequence won't actually be
-            // reproducible. but make it fast (and not cryptographically
-            // secure) anyways, so that the behavior is similar to what you'd
-            // get by passing in a scope.
-            return Random.insecure;
-        }
-        var randomStream = scope.randomStream;
-        if (!randomStream) {
-            scope.randomStream = randomStream = new RandomStream({
-                seed: scope.randomSeed
-            });
-        }
-        return randomStream._sequence(name);
-    };
-
-};
-
-// Returns a random string of sufficient length for a random seed.
-// This is a placeholder function; a similar function is planned
-// for Random itself; when that is added we should remove this function,
-// and call Random's randomToken instead.
-function randomToken() {
-    return Random.hexString(20);
-};
-
-// Creates a randomSeed for passing to a method call.
-// Note that we take enclosing as an argument,
-// though we expect it to be DDP._CurrentMethodInvocation.get()
-// However, we often evaluate makeRpcSeed lazily, and thus the relevant
-// invocation may not be the one currently in scope.
-// If enclosing is null, we'll use Random and values won't be repeatable.
-export function makeRpcSeed(enclosing, methodName) {
-    var stream = RandomStream.get(enclosing, '/rpc/' + methodName);
-    return stream.hexString(20);
-};