Class InMemoryGraphStore

ui/src/store/inMemoryStore.ts:75–437

}

export class InMemoryGraphStore implements GraphStore {
  private nodes = new Map<string, StoredNode>();
  private rels = new Map<string, StoredRel>();
  /** Adjacency index: nodeId → set of outgoing relationship IDs. */
  private outgoing = new Map<string, Set<string>>();
  /** Adjacency index: nodeId → set of incoming relationship IDs. */
  private incoming = new Map<string, Set<string>>();
  private sourceCache = new Map<
    string,
    { content: string; path: string; binary?: boolean }
  >();

  hasData(): boolean {
    return this.nodes.size > 0;
  }

  async importBatch(batch: ImportBatchRequest): Promise<ImportBatchResponse> {
    const t0 = performance.now();
    let nodesCreated = 0;
    let relsCreated = 0;

    for (const n of batch.nodes) {
      const existing = this.nodes.get(n.id);
      if (existing) {
        // Merge properties into existing node (e.g. summary update)
        existing.properties = {
          ...existing.properties,
          ...(n.properties ?? {}),
        };
      } else {
        nodesCreated++;
        this.nodes.set(n.id, {
          id: n.id,
          type: n.type,
          name: n.name,
          properties: n.properties ?? {},
        });
      }
    }

    for (const r of batch.relationships) {
      if (!this.rels.has(r.id)) relsCreated++;
      this.rels.set(r.id, {
        id: r.id,
        type: r.type,
        source_id: r.source_id,
        target_id: r.target_id,
        properties: r.properties ?? {},
      });

      // Maintain adjacency indexes
      let outSet = this.outgoing.get(r.source_id);
      if (!outSet) {
        outSet = new Set();
        this.outgoing.set(r.source_id, outSet);
      }
      outSet.add(r.id);