GraphNormalizer.ts

import * as crypto from 'crypto';

export interface GraphTree {
  node: {
    containerName: string;
    [key: string]: any;
  };
  dependencies: any[];
}

export interface NormalizedGraph {
  definitions: Record<string, any>;
  trees: GraphTree[][];
}

export class GraphNormalizer {
  private definitions: Record<string, any>;

  constructor(definitions: Record<string, any>) {
    this.definitions = definitions;
  }

  public normalize(tree: GraphTree[]): GraphTree[] {
    tree.forEach((node: any) => this.visit(node));
    return tree;
  }

  private visit(obj: any): void {
    if (!obj || typeof obj !== 'object') return;

    if (Array.isArray(obj)) {
      obj.forEach((item) => this.visit(item));
      return;
    }

    if ('returnStructure' in obj) {
      this.extractReturnStructure(obj);
    }

    if (obj.methods && Array.isArray(obj.methods)) {
      obj.methods.forEach((method: any) => this.visit(method));
    }

    if (obj.dependencies) {
      this.visit(obj.dependencies);
    }
    if (obj.node) {
      this.visit(obj.node);
    }
  }

  private extractReturnStructure(obj: any): void {
    const content = obj.returnStructure;
    const contentString = typeof content === 'string' ? content : JSON.stringify(content);

    if (contentString.length > 50) {
      const hash = crypto.createHash('md5').update(contentString).digest('hex').substring(0, 8); // NOSONAR
      const refId = `REF:${hash}`;

      if (!this.definitions[refId]) {
        this.definitions[refId] = content;
      }
      obj.returnStructure = refId;
    }
  }
}