onioncollab/src/onion/legacy/delta_parser.ts.legacy

import {Delta, PrimitiveDelta} from "./delta";

import {
  NodeCreation,
  NodeDeletion,
  EdgeCreation,
  EdgeUpdate,
  EdgeTargetType,
} from "./delta";

import {DeltaRegistry} from "./delta_registry";


import {UUID} from "./types";

export class DeltaParser {
  readonly deltaRegistry: DeltaRegistry;

  constructor(deltaRegistry) {
    this.deltaRegistry = deltaRegistry;
  }

  private getDependency<T>(hash): T {
    const result = this.deltaRegistry.deltas.get(hash);
    if (result === undefined) throw new Error("Could not dependency: " + hash);
    return result as T;
  }

  loadEdgeTarget({type, ...rest}): EdgeTargetType {
    if (type === "value") {
      const {value} = rest;
      return value;
    }
    if (type === "node") {
      const {creation} = rest;
      return this.getDependency<NodeCreation>(creation);
    }
    throw new Error("Unknown edge target type: " + type);
  }

  loadDelta({type, ...rest}): Delta {
    if (type === "NodeCreation") {
      const {id} = rest;
      return this.deltaRegistry.newNodeCreation(new UUID(id));
    }
    if (type === "EdgeCreation") {
      const {source, label, target} = rest;
      return this.deltaRegistry.newEdgeCreation(
        this.getDependency<NodeCreation>(source),
        label,
        this.loadEdgeTarget(target));
    }
    if (type === "EdgeUpdate") {
      const {overwrites, target} = rest;
      return this.deltaRegistry.newEdgeUpdate(
        this.getDependency<EdgeCreation|EdgeUpdate>(overwrites),
        this.loadEdgeTarget(target));
    }
    if (type === "NodeDeletion") {
      const {creation, deletedOutgoingEdges, afterIncomingEdges} = rest;
      return this.deltaRegistry.newNodeDeletion(
        this.getDependency<NodeCreation>(creation),
        deletedOutgoingEdges.map(d => this.getDependency<EdgeCreation|EdgeUpdate>(d)),
        afterIncomingEdges.map(d => this.getDependency<EdgeUpdate|NodeDeletion>(d)));
    }
    if (type === "Transaction") {
      const {type, deltas, dependencies, description} = rest;
      return this.deltaRegistry.newTransaction(
        deltas.map(d => this.getDependency<Delta>(d)),
        description,
        dependencies.map(d => this.getDependency<Delta>(d)));
    }
    throw new Error("Unknown delta type: " + type);
  }
}