atom.io 0.17.0 → 0.18.0

package/realtime-client/dist/index.cjs

@@ -3,6 +3,7 @@
 var Internal3 = require('atom.io/internal');
 var json = require('atom.io/json');
 var AtomIO = require('atom.io');
+var realtimeClient = require('atom.io/realtime-client');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -25,8 +26,8 @@ function _interopNamespace(e) {
 var Internal3__namespace = /*#__PURE__*/_interopNamespace(Internal3);
 var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
 
-// realtime-client/src/pull-state.ts
-function pullState(token, socket, store) {
+// realtime-client/src/pull-atom.ts
+function pullAtom(token, socket, store) {
   const setServedValue = (data) => {
     Internal3.setIntoStore(token, data, store);
   };
@@ -37,7 +38,7 @@ function pullState(token, socket, store) {
     socket.emit(`unsub:${token.key}`);
   };
 }
-function pullFamilyMember(token, socket, store) {
+function pullAtomFamilyMember(token, socket, store) {
   if (!(`family` in token)) {
     console.error(`Token is not a family member:`, token);
     return () => {
@@ -54,7 +55,7 @@ function pullFamilyMember(token, socket, store) {
     socket == null ? void 0 : socket.emit(`unsub:${token.key}`);
   };
 }
-function pullMutableState(token, socket, store) {
+function pullMutableAtom(token, socket, store) {
   const jsonToken = Internal3.getJsonToken(token);
   const updateToken = Internal3.getUpdateToken(token);
   socket.on(`init:${token.key}`, (data) => {
@@ -73,7 +74,7 @@ function pullMutableState(token, socket, store) {
     socket.emit(`unsub:${token.key}`);
   };
 }
-function pullMutableFamilyMember(token, socket, store) {
+function pullMutableAtomFamilyMember(token, socket, store) {
   if (!(`family` in token)) {
     console.error(`Token is not a family member:`, token);
     return () => {
@@ -98,6 +99,69 @@ function pullMutableFamilyMember(token, socket, store) {
     socket == null ? void 0 : socket.emit(`unsub:${token.key}`);
   };
 }
+
+// realtime-client/src/pull-selector.ts
+function pullSelector(token, socket, store) {
+  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
+  const unsubscribes = [];
+  if (atomKeys) {
+    for (const atomKey of atomKeys) {
+      const atom3 = store.atoms.get(atomKey);
+      if (!atom3) {
+        continue;
+      }
+      switch (atom3.type) {
+        case `atom`: {
+          unsubscribes.push(pullAtom(atom3, socket, store));
+          break;
+        }
+        case `mutable_atom`: {
+          unsubscribes.push(pullMutableAtom(atom3, socket, store));
+          break;
+        }
+      }
+    }
+  }
+  return () => {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+  };
+}
+
+// realtime-client/src/pull-selector-family-member.ts
+function pullSelectorFamilyMember(token, socket, store) {
+  if (!(`family` in token)) {
+    console.error(`Token is not a family member:`, token);
+    return () => {
+    };
+  }
+  const atomKeys = store.selectorAtoms.getRelatedKeys(token.key);
+  const unsubscribes = [];
+  if (atomKeys) {
+    for (const atomKey of atomKeys) {
+      const atom3 = store.atoms.get(atomKey);
+      if (!atom3) {
+        continue;
+      }
+      switch (atom3.type) {
+        case `atom`: {
+          unsubscribes.push(pullAtomFamilyMember(atom3, socket, store));
+          break;
+        }
+        case `mutable_atom`: {
+          unsubscribes.push(pullMutableAtomFamilyMember(atom3, socket, store));
+          break;
+        }
+      }
+    }
+  }
+  return () => {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+  };
+}
 function pushState(token, socket, store) {
   socket.emit(`claim:${token.key}`);
   Internal3__namespace.subscribeToState(
@@ -113,6 +177,24 @@ function pushState(token, socket, store) {
     socket.emit(`unclaim:${token.key}`);
   };
 }
+var myIdState__INTERNAL = AtomIO__namespace.atom({
+  key: `mySocketId__INTERNAL`,
+  default: void 0
+});
+var myIdState = AtomIO__namespace.selector({
+  key: `mySocketId`,
+  get: ({ get }) => get(myIdState__INTERNAL)
+});
+var optimisticUpdateQueue = AtomIO__namespace.atom({
+  key: `updateQueue`,
+  default: []
+});
+var confirmedUpdateQueue = AtomIO__namespace.atom(
+  {
+    key: `serverConfirmedUpdateQueue`,
+    default: []
+  }
+);
 function serverAction(token, socket, store) {
   const unsubscribeFromLocalUpdates = Internal3__namespace.subscribeToTransaction(
     token,
@@ -126,35 +208,291 @@ function serverAction(token, socket, store) {
     unsubscribeFromLocalUpdates();
   };
 }
-var myIdState__INTERNAL = AtomIO__namespace.atom({
-  key: `myId__INTERNAL`,
-  default: void 0
-});
-var myIdState = AtomIO__namespace.selector({
-  key: `myId`,
-  get: ({ get }) => get(myIdState__INTERNAL)
-});
-var optimisticUpdateQueueState = AtomIO__namespace.atom({
-  key: `updateQueue`,
-  default: []
-});
-var confirmedUpdateQueueState = AtomIO__namespace.atom({
-  key: `serverConfirmedUpdateQueue`,
-  default: []
-});
-
-// internal/src/transaction/is-root-store.ts
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
+function syncContinuity(continuity, socket, store) {
+  const continuityKey = continuity.key;
+  const optimisticUpdates = Internal3.getFromStore(realtimeClient.optimisticUpdateQueue, store);
+  const confirmedUpdates = Internal3.getFromStore(realtimeClient.confirmedUpdateQueue, store);
+  const initializeContinuity = (epoch, payload) => {
+    let i = 0;
+    let k = ``;
+    let v = null;
+    for (const x of payload) {
+      if (i % 2 === 0) {
+        k = x;
+      } else {
+        v = x;
+        Internal3.setIntoStore(k, v, store);
+      }
+      i++;
+    }
+    Internal3.setEpochNumberOfContinuity(continuityKey, epoch, store);
+  };
+  socket.off(`continuity-init:${continuityKey}`);
+  socket.on(`continuity-init:${continuityKey}`, initializeContinuity);
+  const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
+    function reconcileEpoch(optimisticUpdate, confirmedUpdate2) {
+      store.logger.info(`\u2696\uFE0F`, `continuity`, continuityKey, `reconciling updates`);
+      Internal3.setIntoStore(
+        realtimeClient.optimisticUpdateQueue,
+        (queue) => {
+          queue.shift();
+          return queue;
+        },
+        store
+      );
+      if (optimisticUpdate.id === confirmedUpdate2.id) {
+        const clientResult = JSON.stringify(optimisticUpdate.updates);
+        const serverResult = JSON.stringify(confirmedUpdate2.updates);
+        if (clientResult === serverResult) {
+          store.logger.info(
+            `\u2705`,
+            `continuity`,
+            continuityKey,
+            `results for ${optimisticUpdate.id} match between client and server`
+          );
+          socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+          return;
+        }
+      } else {
+        store.logger.info(
+          `\u274C`,
+          `continuity`,
+          continuityKey,
+          `thought update #${confirmedUpdate2.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate2.key}:${confirmedUpdate2.id}`
+        );
+      }
+      const reversedOptimisticUpdates = optimisticUpdates.toReversed();
+      for (const subsequentOptimistic of reversedOptimisticUpdates) {
+        Internal3.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store);
+      }
+      store.logger.info(
+        `\u23EA`,
+        `continuity`,
+        continuityKey,
+        `undid optimistic updates:`,
+        reversedOptimisticUpdates
+      );
+      Internal3.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store);
+      store.logger.info(
+        `\u23EA`,
+        `continuity`,
+        continuityKey,
+        `undid zeroth optimistic update`,
+        optimisticUpdate
+      );
+      Internal3.ingestTransactionUpdate(`newValue`, confirmedUpdate2, store);
+      store.logger.info(
+        `\u23E9`,
+        `continuity`,
+        continuityKey,
+        `applied confirmed update`,
+        confirmedUpdate2
+      );
+      socket.emit(`ack:${continuityKey}`, confirmedUpdate2.epoch);
+      for (const subsequentOptimistic of optimisticUpdates) {
+        const token = {
+          type: `transaction`,
+          key: subsequentOptimistic.key
+        };
+        const { id, params } = subsequentOptimistic;
+        Internal3.actUponStore(token, id, store)(...params);
+      }
+      store.logger.info(
+        `\u23E9`,
+        `continuity`,
+        continuityKey,
+        `reapplied subsequent optimistic updates:`,
+        optimisticUpdates
+      );
+    }
+    store.logger.info(
+      `\u2696\uFE0F`,
+      `continuity`,
+      continuityKey,
+      `integrating confirmed update`,
+      { confirmedUpdate, confirmedUpdates, optimisticUpdates }
+    );
+    const zerothOptimisticUpdate = optimisticUpdates[0];
+    if (zerothOptimisticUpdate) {
+      store.logger.info(
+        `\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `has optimistic updates to reconcile`
+      );
+      if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
+        store.logger.info(
+          `\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`
+        );
+        reconcileEpoch(zerothOptimisticUpdate, confirmedUpdate);
+        for (const nextConfirmed of confirmedUpdates) {
+          const nextOptimistic = optimisticUpdates[0];
+          if (nextConfirmed.epoch === (nextOptimistic == null ? void 0 : nextOptimistic.epoch)) {
+            reconcileEpoch(nextOptimistic, nextConfirmed);
+          } else {
+            break;
+          }
+        }
+      } else {
+        store.logger.info(
+          `\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `epoch of confirmed update #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`
+        );
+        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+          (update) => update.epoch === confirmedUpdate.epoch
+        );
+        if (!confirmedUpdateIsAlreadyEnqueued) {
+          store.logger.info(
+            `\u{1F448}`,
+            `continuity`,
+            continuityKey,
+            `pushing confirmed update to queue`,
+            confirmedUpdate
+          );
+          Internal3.setIntoStore(
+            realtimeClient.confirmedUpdateQueue,
+            (queue) => {
+              queue.push(confirmedUpdate);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        }
+      }
+    } else {
+      store.logger.info(
+        `\u2696\uFE0F`,
+        `continuity`,
+        continuityKey,
+        `has no optimistic updates to deal with`
+      );
+      const continuityEpoch = Internal3.getEpochNumberOfContinuity(continuityKey, store);
+      const isRoot = Internal3.isRootStore(store);
+      if (isRoot && continuityEpoch === confirmedUpdate.epoch - 1) {
+        store.logger.info(
+          `\u2705`,
+          `continuity`,
+          continuityKey,
+          `integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`
+        );
+        Internal3.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
+        socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch);
+        Internal3.setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store);
+      } else if (isRoot && continuityEpoch !== void 0) {
+        store.logger.info(
+          `\u2696\uFE0F`,
+          `continuity`,
+          continuityKey,
+          `received update #${confirmedUpdate.epoch} but still waiting for update #${continuityEpoch + 1}`,
+          {
+            clientEpoch: continuityEpoch,
+            serverEpoch: confirmedUpdate.epoch
+          }
+        );
+        const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+          (update) => update.epoch === confirmedUpdate.epoch
+        );
+        if (confirmedUpdateIsAlreadyEnqueued) {
+          store.logger.info(
+            `\u{1F44D}`,
+            `continuity`,
+            continuityKey,
+            `confirmed update #${confirmedUpdate.epoch} is already enqueued`
+          );
+        } else {
+          store.logger.info(
+            `\u{1F448}`,
+            `continuity`,
+            continuityKey,
+            `pushing confirmed update #${confirmedUpdate.epoch} to queue`
+          );
+          Internal3.setIntoStore(
+            realtimeClient.confirmedUpdateQueue,
+            (queue) => {
+              queue.push(confirmedUpdate);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        }
+      }
+    }
+  };
+  socket.off(`tx-new:${continuityKey}`);
+  socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate);
+  const unsubscribeFunctions = continuity.actions.map((transaction) => {
+    Internal3.assignTransactionToContinuity(continuityKey, transaction.key, store);
+    const unsubscribeFromTransactionUpdates = Internal3.subscribeToTransaction(
+      transaction,
+      (clientUpdate) => {
+        store.logger.info(
+          `\u{1F91E}`,
+          `continuity`,
+          continuityKey,
+          `enqueuing optimistic update`
+        );
+        const optimisticUpdateIndex = optimisticUpdates.findIndex(
+          (update) => update.id === clientUpdate.id
+        );
+        if (optimisticUpdateIndex === -1) {
+          store.logger.info(
+            `\u{1F91E}`,
+            `continuity`,
+            continuityKey,
+            `enqueuing new optimistic update`
+          );
+          Internal3.setIntoStore(
+            realtimeClient.optimisticUpdateQueue,
+            (queue) => {
+              queue.push(clientUpdate);
+              queue.sort((a, b) => a.epoch - b.epoch);
+              return queue;
+            },
+            store
+          );
+        } else {
+          store.logger.info(
+            `\u{1F91E}`,
+            `continuity`,
+            continuityKey,
+            `replacing existing optimistic update at index ${optimisticUpdateIndex}`
+          );
+          Internal3.setIntoStore(
+            realtimeClient.optimisticUpdateQueue,
+            (queue) => {
+              queue[optimisticUpdateIndex] = clientUpdate;
+              return queue;
+            },
+            store
+          );
+        }
+        socket.emit(`tx-run:${continuityKey}`, clientUpdate);
+      },
+      `tx-run:${continuityKey}`,
+      store
+    );
+    return unsubscribeFromTransactionUpdates;
+  });
+  socket.emit(`get:${continuityKey}`);
+  return () => {
+    socket.off(`continuity-init:${continuityKey}`);
+    socket.off(`tx-new:${continuityKey}`);
+    for (const unsubscribe of unsubscribeFunctions)
+      unsubscribe();
+    socket.emit(`unsub:${continuityKey}`);
+  };
 }
-
-// realtime-client/src/sync-server-action.ts
 function syncAction(token, socket, store) {
-  const optimisticQueue = Internal3__namespace.getFromStore(
-    optimisticUpdateQueueState,
-    store
-  );
-  const confirmedQueue = Internal3__namespace.getFromStore(confirmedUpdateQueueState, store);
+  Internal3__namespace.assignTransactionToContinuity(`default`, token.key, store);
+  const optimisticQueue = Internal3__namespace.getFromStore(optimisticUpdateQueue, store);
+  const confirmedQueue = Internal3__namespace.getFromStore(confirmedUpdateQueue, store);
   const unsubscribeFromLocalUpdates = Internal3__namespace.subscribeToTransaction(
     token,
     (clientUpdate) => {
@@ -163,7 +501,7 @@ function syncAction(token, socket, store) {
       );
       if (optimisticUpdateQueueIndex === -1) {
         Internal3__namespace.setIntoStore(
-          optimisticUpdateQueueState,
+          optimisticUpdateQueue,
           (queue) => {
             queue.push(clientUpdate);
             queue.sort((a, b) => a.epoch - b.epoch);
@@ -171,25 +509,24 @@ function syncAction(token, socket, store) {
           },
           store
         );
-        socket.emit(`tx-run:${token.key}`, clientUpdate);
       } else {
         Internal3__namespace.setIntoStore(
-          optimisticUpdateQueueState,
+          optimisticUpdateQueue,
           (queue) => {
             queue[optimisticUpdateQueueIndex] = clientUpdate;
             return queue;
           },
           store
         );
-        socket.emit(`tx-run:${token.key}`, clientUpdate);
       }
+      socket.emit(`tx-run:${token.key}`, clientUpdate);
     },
     `tx-run:${token.key}`,
     store
   );
   const reconcileUpdates = (optimisticUpdate, confirmedUpdate) => {
     Internal3__namespace.setIntoStore(
-      optimisticUpdateQueueState,
+      optimisticUpdateQueue,
       (queue) => {
         queue.shift();
         return queue;
@@ -229,7 +566,7 @@ function syncAction(token, socket, store) {
         subsequentOptimistic
       );
       const { id, params } = subsequentOptimistic;
-      AtomIO__namespace.runTransaction(token2, id, store)(...params);
+      Internal3__namespace.actUponStore(token2, id, store)(...params);
     }
   };
   const registerAndAttemptConfirmedUpdate = (confirmedUpdate) => {
@@ -251,7 +588,7 @@ function syncAction(token, socket, store) {
         );
         if (hasEnqueuedOptimisticUpdate) {
           Internal3__namespace.setIntoStore(
-            confirmedUpdateQueueState,
+            confirmedUpdateQueue,
             (queue) => {
               queue.push(confirmedUpdate);
               queue.sort((a, b) => a.epoch - b.epoch);
@@ -262,11 +599,12 @@ function syncAction(token, socket, store) {
         }
       }
     } else {
-      if (isRootStore(store) && store.transactionMeta.epoch === confirmedUpdate.epoch - 1) {
+      const continuityEpoch = Internal3__namespace.getEpochNumberOfAction(token.key, store);
+      if (Internal3__namespace.isRootStore(store) && continuityEpoch === confirmedUpdate.epoch - 1) {
         Internal3__namespace.ingestTransactionUpdate(`newValue`, confirmedUpdate, store);
         socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch);
-        store.transactionMeta.epoch = confirmedUpdate.epoch;
-      } else if (isRootStore(store)) {
+        Internal3__namespace.setEpochNumberOfAction(token.key, confirmedUpdate.epoch, store);
+      } else if (Internal3__namespace.isRootStore(store)) {
         store.logger.info(
           `\u274C`,
           `transaction`,
@@ -303,17 +641,20 @@ function syncState(token, socket, store) {
   };
 }
 
-exports.confirmedUpdateQueueState = confirmedUpdateQueueState;
+exports.confirmedUpdateQueue = confirmedUpdateQueue;
 exports.myIdState = myIdState;
 exports.myIdState__INTERNAL = myIdState__INTERNAL;
-exports.optimisticUpdateQueueState = optimisticUpdateQueueState;
-exports.pullFamilyMember = pullFamilyMember;
-exports.pullMutableFamilyMember = pullMutableFamilyMember;
-exports.pullMutableState = pullMutableState;
-exports.pullState = pullState;
+exports.optimisticUpdateQueue = optimisticUpdateQueue;
+exports.pullAtom = pullAtom;
+exports.pullAtomFamilyMember = pullAtomFamilyMember;
+exports.pullMutableAtom = pullMutableAtom;
+exports.pullMutableAtomFamilyMember = pullMutableAtomFamilyMember;
+exports.pullSelector = pullSelector;
+exports.pullSelectorFamilyMember = pullSelectorFamilyMember;
 exports.pushState = pushState;
 exports.serverAction = serverAction;
 exports.syncAction = syncAction;
+exports.syncContinuity = syncContinuity;
 exports.syncState = syncState;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map