chore(json-crdt): 🤖 progress on history implementation

Author: streamich

src/json-crdt/history/LocalHistoryCrud.ts

@@ -52,8 +52,18 @@ export class LocalHistoryCrud implements LocalHistory {
     throw new Error('Method not implemented.');
   }
 
-  public update(collection: string[], id: string, patches: Patch[]): Promise<void> {
-    throw new Error('Method not implemented.');
+  public async update(collection: string[], id: string, patches: Patch[]): Promise<void> {
+    await this.lock(collection, id, async () => {
+      const blob = await this.crud.get([...collection, id], STATE_FILE_NAME);
+      const {log} = File.fromSeqCbor(blob);
+      log.end.applyBatch(patches);
+      const file = new File(log.end, log, this.fileOpts);
+      const blob2 = file.toBinary({
+        format: "seq.cbor",
+        model: 'binary',
+      });
+      await this.crud.put([...collection, id], STATE_FILE_NAME, blob2, {throwIf: 'missing'});
+    });
   }
 
   public async delete(collection: string[], id: string): Promise<void> {

src/json-crdt/history/SessionHistory.ts

@@ -0,0 +1,74 @@
+import {createRace} from 'thingies/es2020/createRace';
+import {FanOutUnsubscribe} from 'thingies/es2020/fanout';
+import {InsValOp, Patch} from "../../json-crdt-patch";
+import {ValNode} from "../nodes";
+import {toSchema} from "../schema/toSchema";
+import {PatchLog} from "./PatchLog";
+import {RedoItem, UndoItem, UndoRedoStack} from "./UndoRedoStack";
+
+class Undo implements UndoItem {
+  constructor (public readonly undo: () => Redo) {}
+}
+
+class Redo implements RedoItem {
+  constructor (public readonly redo: () => Undo) {}
+}
+
+export class SessionHistory {
+  constructor (
+    public readonly log: PatchLog,
+  ) {}
+  
+  private readonly __onPatchRace = createRace();
+
+  public attachUndoRedo(stack: UndoRedoStack): FanOutUnsubscribe {
+    const onBeforePatch = (patch: Patch) => {
+      this.__onPatchRace(() => {
+        const undo = this.createUndo(patch);
+        stack.push(undo);
+      });
+    };
+    const unsubscribe = this.log.end.api.onBeforePatch.listen(onBeforePatch);
+    return unsubscribe;
+  }
+
+  public createUndo(patch: Patch): Undo {
+    const undoTasks: Array<() => void> = [];
+    const ops = patch.ops;
+    const length = ops.length;
+    for (let i = length - 1; i >= 0; i--) {
+      const op = ops[i];
+      switch (op.name()) {
+        case 'ins_val': {
+          const insOp = op as InsValOp;
+          const valNode = this.log.end.index.get(insOp.obj);
+          if (!(valNode instanceof ValNode)) throw new Error('INVALID_NODE');
+          const copy = toSchema(valNode.node());
+          const valNodeId = valNode.id;
+          const task = () => {
+            const end = this.log.end;
+            const valNode = end.index.get(valNodeId);
+            if (!valNode) return;
+            end.api.wrap(valNode).asVal().set(copy);
+          };
+          undoTasks.push(task);
+        }
+      }
+    }
+    const undo = new Undo(() => {
+      this.__onPatchRace(() => {
+        for (const task of undoTasks) task();
+      });
+      return new Redo(() => {
+        const undo = this.__onPatchRace(() => {
+          // TODO: This line needs to be changed:
+          const redoPatch = Patch.fromBinary(patch.toBinary());
+          this.log.end.api.builder.patch = redoPatch;
+          return this.createUndo(redoPatch);
+        });
+        return undo!;
+      });
+    });
+    return undo;
+  }
+}