Class InMemoryGraphStorage

packages/graph/src/GraphStorage.ts:131–358

}

export class InMemoryGraphStorage implements GraphStorage {
  #vertices: Map<ElementId, StoredVertex>;
  #edges: Map<ElementId, StoredEdge>;
  #incomingEdges: Map<ElementId, StoredEdge[]>;
  #outgoingEdges: Map<ElementId, StoredEdge[]>;

  public constructor(data?: { vertices: StoredVertex[]; edges: StoredEdge[] }) {
    const vertices: Map<ElementId, StoredVertex> = new Map();
    const edges: Map<ElementId, StoredEdge> = new Map();

    this.#vertices = vertices;
    this.#edges = edges;
    this.#incomingEdges = new Map();
    this.#outgoingEdges = new Map();
    if (data != null) {
      for (const vertex of data.vertices) {
        this.addVertex(vertex);
      }
      for (const edge of data.edges) {
        this.addEdge(edge);
      }
    }
  }

  protected get vertices(): Map<ElementId, StoredVertex> {
    return this.#vertices;
  }

  protected get edges(): Map<ElementId, StoredEdge> {
    return this.#edges;
  }

  protected get incomingEdges(): Map<ElementId, StoredEdge[]> {
    return this.#incomingEdges;
  }

  protected get outgoingEdges(): Map<ElementId, StoredEdge[]> {
    return this.#outgoingEdges;
  }

  public getVertexById(id: ElementId): StoredVertex | undefined {
    return this.#vertices.get(id);
  }

  public *getVertices(labels: string[]): Iterable<StoredVertex> {
    // Snapshot keys to prevent infinite loops when vertices are added during iteration.
    // Keys are just strings so this is cheap; actual vertex data is still fetched lazily.
    const keys = [...this.#vertices.keys()];
    for (const key of keys) {
      const vertex = this.#vertices.get(key);
      if (
        vertex !== undefined &&
        (labels.length === 0 || labels.includes(getLabelFromElementId(vertex.id)))
      ) {
        yield vertex;
      }
    }
  }