Feat/#111-BK: 회의록 CRDT 추가 (#115)

회의록 동시 편집 기능에 사용될 자료구조

Author: se030

client/src/utils/crdt/index.ts

@@ -0,0 +1,72 @@
+import LinkedList from './linked-list';
+import { Identifier, Node } from './node';
+
+interface RemoteInsertOperation {
+  prevId: Identifier | null;
+  node: Node;
+}
+
+interface RemoteRemoveOperation {
+  targetId: Identifier | null;
+  clock: number;
+}
+
+class CRDT {
+  clock: number;
+  client: number;
+  private structure: LinkedList;
+
+  constructor(initialclock: number, client: number) {
+    this.clock = initialclock;
+    this.client = client;
+    this.structure = new LinkedList();
+  }
+
+  generateNode(letter: string) {
+    const id = this.generateIdentifier();
+    return new Node(letter, id);
+  }
+
+  generateIdentifier() {
+    return new Identifier(this.clock++, this.client);
+  }
+
+  localInsert(index: number, letter: string): RemoteInsertOperation {
+    const node = this.generateNode(letter);
+    const prevId = this.structure.insertByIndex(index, node);
+
+    return { prevId, node };
+  }
+
+  localDelete(index: number): RemoteRemoveOperation {
+    const targetId = this.structure.deleteByIndex(index);
+
+    return { targetId, clock: this.clock };
+  }
+
+  remoteInsert({ prevId, node }: RemoteInsertOperation) {
+    const prevIndex = this.structure.insertById(prevId, node);
+
+    if (++this.clock < node.id.clock) {
+      this.clock = node.id.clock + 1;
+    }
+
+    return prevIndex;
+  }
+
+  remoteDelete({ targetId, clock }: RemoteRemoveOperation) {
+    const targetIndex = this.structure.deleteById(targetId);
+
+    if (++this.clock < clock) {
+      this.clock = clock + 1;
+    }
+
+    return targetIndex;
+  }
+
+  read() {
+    return this.structure.stringify();
+  }
+}
+
+export default CRDT;

client/src/utils/crdt/linked-list.ts

@@ -0,0 +1,147 @@
+import { Identifier, Node } from './node';
+
+type RemoteIdentifier = Identifier | null;
+
+type ModifiedIndex = number | null;
+
+export default class LinkedList {
+  head?: Node;
+
+  insertByIndex(index: number, node: Node): RemoteIdentifier {
+    try {
+      if (!this.head || index === -1) {
+        node.next = this.head;
+        this.head = node;
+
+        return null;
+      }
+      const prevNode = this.findByIndex(index);
+
+      node.next = prevNode.next;
+      prevNode.next = node;
+
+      const { id: prevNodeId } = prevNode;
+      return prevNodeId;
+    } catch (e) {
+      console.log(`insertByIndex 실패 ^^\n${e}`);
+
+      return null;
+    }
+  }
+
+  deleteByIndex(index: number): RemoteIdentifier {
+    try {
+      if (!index) {
+        if (!this.head) throw new Error('head가 없는데 어떻게 삭제하셨나요 ^^');
+
+        this.head = this.head.next;
+
+        return null;
+      }
+
+      const prevNode = this.findByIndex(index - 1);
+
+      const targetNode = prevNode.next;
+
+      prevNode.next = targetNode?.next;
+
+      if (!targetNode || !targetNode.id) return null;
+
+      return targetNode.id;
+    } catch (e) {
+      console.log(`deleteByIndex 실패 ^^\n${e}`);
+
+      return null;
+    }
+  }
+
+  insertById(id: RemoteIdentifier, node: Node): ModifiedIndex {
+    try {
+      if (id === null) {
+        node.next = this.head;
+        this.head = node;
+
+        return 0;
+      }
+
+      const { node: prevNode, index: prevIndex } = this.findById(id);
+
+      node.next = prevNode.next;
+      prevNode.next = node;
+
+      return prevIndex + 1;
+    } catch (e) {
+      console.log(`insertById 실패 ^^\n${e}`);
+
+      return null;
+    }
+  }
+
+  deleteById(id: RemoteIdentifier): ModifiedIndex {
+    try {
+      if (!id) {
+        if (!this.head) throw new Error('일어날 수 없는 일이 발생했어요 ^^');
+
+        this.head = this.head.next;
+
+        return null;
+      }
+
+      const { node: targetNode, index: targetIndex } = this.findById(id);
+      const prevNode = this.findByIndex(targetIndex - 1);
+
+      prevNode.next = targetNode.next;
+
+      return targetIndex;
+    } catch (e) {
+      console.log(`deleteById 실패 ^^\n${e}`);
+
+      return null;
+    }
+  }
+
+  stringify(): string {
+    if (!this.head) {
+      return '';
+    }
+
+    let node: Node | undefined = this.head;
+    let result = '';
+
+    while (node) {
+      result += node.value;
+      node = node.next;
+    }
+    return result;
+  }
+
+  private findByIndex(index: number): Node {
+    let count = 0;
+    let currentNode: Node | undefined = this.head;
+
+    while (count < index && currentNode) {
+      currentNode = currentNode.next;
+      count++;
+    }
+
+    if (!currentNode) throw new Error('없는 인덱스인데요 ^^');
+
+    return currentNode;
+  }
+
+  private findById(id: Identifier) {
+    let count = 0;
+    let currentNode: Node | undefined = this.head;
+
+    while (currentNode) {
+      if (JSON.stringify(currentNode.id) === JSON.stringify(id)) {
+        return { node: currentNode, index: count };
+      }
+
+      currentNode = currentNode.next;
+      count++;
+    }
+
+    throw new Error('없는 노드인데요 ^^');
+  }
+}

client/src/utils/crdt/node.ts

@@ -0,0 +1,28 @@
+export class Identifier {
+  clock: number;
+  client: number;
+
+  constructor(clock: number, client: number) {
+    this.clock = clock;
+    this.client = client;
+  }
+}
+
+export class Node {
+  id: Identifier;
+  value?: string;
+  next?: Node;
+
+  constructor(value: string, id: Identifier) {
+    this.id = id;
+    this.value = value;
+  }
+
+  precedes(id: Identifier) {
+    if (this.id.clock < id.clock) return true;
+
+    if (this.id.clock === id.clock && this.id.client < id.client) return true;
+
+    return false;
+  }
+}