mongodb-livedata-server 0.0.1

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

@@ -0,0 +1,119 @@
+import { DiffSequence } from "../diff-sequence/diff";
+import { equals } from "../ejson/ejson";
+import { SessionDocumentView } from "./session-document-view";
+
+interface SubscriptionCallbacks {
+    added: (collectionName: string, id: string, fields: Record<string, any>) => void;
+    changed: (collectionName: string, id: string, fields: Record<string, any>) => void;
+    removed: (collectionName: string, id: string) => void;
+}
+
+interface SubscriptionHandle {
+
+}
+
+/**
+ * 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
+ */
+export class SessionCollectionView {
+
+    private documents = new Map();
+    constructor (private collectionName: string, private callbacks: SubscriptionCallbacks) { }
+
+    isEmpty() {
+        return this.documents.size === 0;
+    }
+
+    diff(previous: SessionCollectionView) {
+        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: string, prevDV: SessionDocumentView, nowDV: SessionDocumentView) {
+        const fields = {};
+        DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {
+            both: (key: string, prev: any, now: any) => {
+                if (!equals(prev, now))
+                    fields[key] = now;
+            },
+            rightOnly: (key: string, now: any) => {
+                fields[key] = now;
+            },
+            leftOnly: (key: string, prev: any) => {
+                fields[key] = undefined;
+            }
+        });
+        this.callbacks.changed(this.collectionName, id, fields);
+    }
+
+    added(subscriptionHandle: SubscriptionHandle, id: string, fields: Record<string, any>) {
+        var self = this;
+        var docView = self.documents.get(id);
+        var added = false;
+        if (!docView) {
+            added = true;
+            docView = new 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: SubscriptionHandle, id: string, changed: Record<string, any>) {
+        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: string) {
+        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);
+        }
+    }
+}

package/meteor/ddp/session-document-view.ts

@@ -0,0 +1,92 @@
+import { clone, equals } from "../ejson/ejson";
+
+interface PrecedenceItem {
+    subscriptionHandle: any;
+    value: any;
+}
+
+// Represents a single document in a SessionCollectionView
+export class SessionDocumentView {
+    public existsIn: Set<any>; // set of subscriptionHandle
+    private dataByKey: Map<string, PrecedenceItem[]>; // key-> [ {subscriptionHandle, value} by precedence]
+    constructor() {
+        this.existsIn = new Set();
+        this.dataByKey = new Map();
+    };
+
+    getFields() {
+        var ret: Record<string, any> = {};
+        this.dataByKey.forEach((precedenceList, key) => {
+            ret[key] = precedenceList[0].value;
+        });
+        return ret;
+    }
+
+    clearField(subscriptionHandle, key: string, changeCollector: Object) {
+        // Publish API ignores _id if present in fields
+        if (key === "_id")
+            return;
+        const precedenceList = this.dataByKey.get(key);
+
+        // It's okay to clear fields that didn't exist. No need to throw
+        // an error.
+        if (!precedenceList)
+            return;
+
+        let removedValue = undefined;
+        for (var i = 0; i < precedenceList.length; i++) {
+            var precedence = precedenceList[i];
+            if (precedence.subscriptionHandle === subscriptionHandle) {
+                // The view's value can only change if this subscription is the one that
+                // used to have precedence.
+                if (i === 0)
+                    removedValue = precedence.value;
+                precedenceList.splice(i, 1);
+                break;
+            }
+        }
+        if (precedenceList.length === 0) {
+            this.dataByKey.delete(key);
+            changeCollector[key] = undefined;
+        } else if (removedValue !== undefined && !equals(removedValue, precedenceList[0].value)) {
+            changeCollector[key] = precedenceList[0].value;
+        }
+    }
+
+    changeField(subscriptionHandle, key: string, value: any, changeCollector: Object, isAdd: boolean) {
+        // Publish API ignores _id if present in fields
+        if (key === "_id")
+            return;
+
+        // Don't share state with the data passed in by the user.
+        value = clone(value);
+
+        if (!this.dataByKey.has(key)) {
+            this.dataByKey.set(key, [{
+                subscriptionHandle: subscriptionHandle,
+                value: value
+            }]);
+            changeCollector[key] = value;
+            return;
+        }
+        const precedenceList = this.dataByKey.get(key);
+        let elt;
+        if (!isAdd) {
+            elt = precedenceList.find(precedence => {
+                return precedence.subscriptionHandle === subscriptionHandle;
+            });
+        }
+
+        if (elt) {
+            if (elt === precedenceList[0] && !equals(value, elt.value)) {
+                // this subscription is changing the value of this field.
+                changeCollector[key] = value;
+            }
+            elt.value = value;
+        } else {
+            // this subscription is newly caring about this field
+            precedenceList.push({ subscriptionHandle: subscriptionHandle, value: value });
+        }
+
+    }
+}