feat(json-crdt-patch): 🎸 implement consecutive string insert compaction

Author: streamich

src/json-crdt-patch/__tests__/compaction.spec.ts

@@ -1,7 +1,6 @@
-import {LogicalClock} from '../clock';
-import {combine} from '../compaction';
-import {SESSION} from '../constants';
-import {NopOp} from '../operations';
+import {equal, LogicalClock, tick, ts} from '../clock';
+import {combine, compact} from '../compaction';
+import {InsStrOp, NopOp} from '../operations';
 import {Patch} from '../Patch';
 import {PatchBuilder} from '../PatchBuilder';
 
@@ -87,3 +86,86 @@ describe('.combine()', () => {
     combine(patch1, patch2)
   });
 });
+
+describe('.compact()', () => {
+  test('can combine two consecutive string inserts', () => {
+    const builder = new PatchBuilder(new LogicalClock(123456789, 1));
+    const strId = builder.str();
+    const ins1Id = builder.insStr(strId, strId, 'hello');
+    builder.insStr(strId, tick(ins1Id, 'hello'.length - 1), ' world');
+    builder.root(strId);
+    const patch = builder.flush();
+    const patch2 = patch.clone();
+    compact(patch);
+    expect(equal(patch.ops[0].id, patch2.ops[0].id)).toBe(true);
+    expect(equal(patch.ops[1].id, patch2.ops[1].id)).toBe(true);
+    expect(equal(patch.ops[2].id, patch2.ops[3].id)).toBe(true);
+    expect((patch.ops[1] as any).data).toBe('hello world');
+  });
+
+  test('can combine two consecutive string inserts - 2', () => {
+    const builder = new PatchBuilder(new LogicalClock(123456789, 1));
+    const strId = builder.str();
+    const ins1Id = builder.insStr(strId, strId, 'a');
+    builder.insStr(strId, tick(ins1Id, 'a'.length - 1), 'b');
+    builder.root(strId);
+    const patch = builder.flush();
+    const patch2 = patch.clone();
+    compact(patch);
+    expect(equal(patch.ops[0].id, patch2.ops[0].id)).toBe(true);
+    expect(equal(patch.ops[1].id, patch2.ops[1].id)).toBe(true);
+    expect(equal(patch.ops[2].id, patch2.ops[3].id)).toBe(true);
+    expect((patch.ops[1] as any).data).toBe('ab');
+  });
+
+  test('can combine two consecutive string inserts - 3', () => {
+    const patch = new Patch();
+    patch.ops.push(new InsStrOp(ts(123, 30), ts(123, 10), ts(123, 20), 'a'));
+    patch.ops.push(new InsStrOp(ts(123, 31), ts(123, 10), ts(123, 30), 'b'));
+    compact(patch);
+    expect(patch.ops.length).toBe(1);
+    expect((patch.ops[0] as InsStrOp).data).toBe('ab');
+  });
+
+  test('does not combine inserts, if they happen into different strings', () => {
+    const patch = new Patch();
+    patch.ops.push(new InsStrOp(ts(123, 30), ts(123, 10), ts(123, 20), 'a'));
+    patch.ops.push(new InsStrOp(ts(123, 31), ts(123, 99), ts(123, 30), 'b'));
+    compact(patch);
+    expect(patch.ops.length).toBe(2);
+  });
+
+  test('does not combine inserts, if time is not consecutive', () => {
+    const patch = new Patch();
+    patch.ops.push(new InsStrOp(ts(123, 30), ts(123, 10), ts(123, 20), 'a'));
+    patch.ops.push(new InsStrOp(ts(123, 99), ts(123, 10), ts(123, 30), 'b'));
+    compact(patch);
+    expect(patch.ops.length).toBe(2);
+  });
+
+  test('does not combine inserts, if the second operation is not an append', () => {
+    const patch = new Patch();
+    patch.ops.push(new InsStrOp(ts(123, 30), ts(123, 10), ts(123, 20), 'a'));
+    patch.ops.push(new InsStrOp(ts(123, 31), ts(123, 10), ts(123, 22), 'b'));
+    compact(patch);
+    expect(patch.ops.length).toBe(2);
+  });
+
+  test('does not combine inserts, if the second operation is not an append - 2', () => {
+    const patch = new Patch();
+    patch.ops.push(new InsStrOp(ts(123, 30), ts(123, 10), ts(123, 20), 'a'));
+    patch.ops.push(new InsStrOp(ts(123, 31), ts(123, 10), ts(999, 30), 'b'));
+    compact(patch);
+    expect(patch.ops.length).toBe(2);
+  });
+
+  test('returns a patch as-is', () => {
+    const builder = new PatchBuilder(new LogicalClock(123456789, 1));
+    builder.root(builder.json({str: 'hello'}));
+    const patch = builder.flush();
+    const str1 = patch + '';
+    compact(patch);
+    const str2 = patch + '';
+    expect(str2).toBe(str1);
+  });
+});

src/json-crdt-patch/compaction.ts

@@ -3,9 +3,9 @@
  *     together, and cleaning up operations.
  */
 
-import {Timestamp} from "./clock";
-import {NopOp} from "./operations";
-import type {Patch} from "./Patch";
+import {equal, Timestamp} from "./clock";
+import {InsStrOp, NopOp} from "./operations";
+import type {JsonCrdtPatchOperation, Patch} from "./Patch";
 
 /**
  * Combines two patches together. The first patch is modified in place.
@@ -39,3 +39,34 @@ export const combine = (a: Patch, b: Patch): void => {
   if (needsNoop) a.ops.push(new NopOp(new Timestamp(sidA, nextTick), timeDiff));
   a.ops = a.ops.concat(b.ops);
 };
+
+/**
+ * Compacts operations within a patch. Combines consecutive string inserts.
+ * Mutates the operations in place. (Use `patch.clone()` to avoid mutating the
+ * original patch.)
+ *
+ * @param patch The patch to compact.
+ */
+export const compact = (patch: Patch): void => {
+  const ops = patch.ops;
+  const length = ops.length;
+  let lastOp: JsonCrdtPatchOperation = ops[0];
+  const newOps: JsonCrdtPatchOperation[] = [lastOp];
+  for (let i = 1; i < length; i++) {
+    const op = ops[i];
+    if (lastOp instanceof InsStrOp && op instanceof InsStrOp) {
+      const lastOpNextTick = lastOp.id.time + lastOp.span();
+      const isTimeConsecutive = lastOpNextTick === op.id.time;
+      const isInsertIntoSameString = equal(lastOp.obj, op.obj);
+      const opRef = op.ref;
+      const isAppend = (lastOpNextTick === (opRef.time + 1)) && (lastOp.ref.sid === opRef.sid);
+      if (isTimeConsecutive && isInsertIntoSameString && isAppend) {
+        lastOp.data = lastOp.data + op.data;
+        continue;
+      }
+    }
+    newOps.push(op);
+    lastOp = op;
+  }
+  patch.ops = newOps;
+};

src/json-crdt-patch/operations.ts

@@ -262,7 +262,7 @@ export class InsStrOp implements IJsonCrdtPatchEditOperation {
     public readonly id: ITimestampStruct,
     public readonly obj: ITimestampStruct,
     public readonly ref: ITimestampStruct,
-    public readonly data: string,
+    public data: string,
   ) {}
 
   public span(): number {