mongodb-livedata-server 0.0.1

package/dist/meteor/ddp/livedata_server.js

@@ -0,0 +1,403 @@
+"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)) {
+            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;
+    }
+    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;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodInvocation = void 0;
+// Instance name is this because it is usually referred to as this inside a
+// method definition
+/**
+ * @summary The state for a single invocation of a method, referenced by this
+ * inside a method definition.
+ * @param {Object} options
+ * @instanceName this
+ * @showInstanceName true
+ */
+class MethodInvocation {
+    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) {
+        this.userId = userId;
+        this._setUserId(userId);
+    }
+}
+exports.MethodInvocation = MethodInvocation;
+;

package/dist/meteor/ddp/random-stream.js

@@ -0,0 +1,100 @@
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRpcSeed = exports.RandomStream = void 0;
+const main_1 = require("../random/main");
+//                          If omitted, a random array will be used as the seed.
+class RandomStream {
+    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 = main_1.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 main_1.Random.insecure;
+        }
+        var randomStream = scope.randomStream;
+        if (!randomStream) {
+            scope.randomStream = randomStream = new RandomStream({
+                seed: scope.randomSeed
+            });
+        }
+        return randomStream._sequence(name);
+    }
+    ;
+}
+exports.RandomStream = RandomStream;
+;
+// 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 main_1.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.
+function makeRpcSeed(enclosing, methodName) {
+    var stream = RandomStream.get(enclosing, '/rpc/' + methodName);
+    return stream.hexString(20);
+}
+exports.makeRpcSeed = makeRpcSeed;
+;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionCollectionView = void 0;
+const diff_1 = require("../diff-sequence/diff");
+const ejson_1 = require("../ejson/ejson");
+const session_document_view_1 = require("./session-document-view");
+/**
+ * Represents a client's view of a single collection
+ * @param {String} collectionName Name of the collection it represents
+ * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed
+ * @class SessionCollectionView
+ */
+class SessionCollectionView {
+    constructor(collectionName, callbacks) {
+        this.collectionName = collectionName;
+        this.callbacks = callbacks;
+        this.documents = new Map();
+    }
+    isEmpty() {
+        return this.documents.size === 0;
+    }
+    diff(previous) {
+        diff_1.DiffSequence.diffMaps(previous.documents, this.documents, {
+            both: this.diffDocument.bind(this),
+            rightOnly: (id, nowDV) => {
+                this.callbacks.added(this.collectionName, id, nowDV.getFields());
+            },
+            leftOnly: (id, prevDV) => {
+                this.callbacks.removed(this.collectionName, id);
+            }
+        });
+    }
+    diffDocument(id, prevDV, nowDV) {
+        const fields = {};
+        diff_1.DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {
+            both: (key, prev, now) => {
+                if (!(0, ejson_1.equals)(prev, now))
+                    fields[key] = now;
+            },
+            rightOnly: (key, now) => {
+                fields[key] = now;
+            },
+            leftOnly: (key, prev) => {
+                fields[key] = undefined;
+            }
+        });
+        this.callbacks.changed(this.collectionName, id, fields);
+    }
+    added(subscriptionHandle, id, fields) {
+        var self = this;
+        var docView = self.documents.get(id);
+        var added = false;
+        if (!docView) {
+            added = true;
+            docView = new session_document_view_1.SessionDocumentView();
+            self.documents.set(id, docView);
+        }
+        docView.existsIn.add(subscriptionHandle);
+        var changeCollector = {};
+        for (const [key, value] of Object.entries(fields)) {
+            docView.changeField(subscriptionHandle, key, value, changeCollector, true);
+        }
+        if (added)
+            self.callbacks.added(self.collectionName, id, changeCollector);
+        else
+            self.callbacks.changed(self.collectionName, id, changeCollector);
+    }
+    changed(subscriptionHandle, id, changed) {
+        var self = this;
+        var changedResult = {};
+        var docView = self.documents.get(id);
+        if (!docView)
+            throw new Error("Could not find element with id " + id + " to change");
+        for (const [key, value] of Object.entries(changed)) {
+            if (value === undefined)
+                docView.clearField(subscriptionHandle, key, changedResult);
+            else
+                docView.changeField(subscriptionHandle, key, value, changedResult);
+        }
+        self.callbacks.changed(self.collectionName, id, changedResult);
+    }
+    removed(subscriptionHandle, id) {
+        var self = this;
+        var docView = self.documents.get(id);
+        if (!docView) {
+            var err = new Error("Removed nonexistent document " + id);
+            throw err;
+        }
+        docView.existsIn.delete(subscriptionHandle);
+        if (docView.existsIn.size === 0) {
+            // it is gone from everyone
+            self.callbacks.removed(self.collectionName, id);
+            self.documents.delete(id);
+        }
+        else {
+            var changed = {};
+            // remove this subscription from every precedence list
+            // and record the changes
+            docView.dataByKey.forEach((precedenceList, key) => {
+                docView.clearField(subscriptionHandle, key, changed);
+            });
+            self.callbacks.changed(self.collectionName, id, changed);
+        }
+    }
+}
+exports.SessionCollectionView = SessionCollectionView;