index.ts

import { DependencyInjectionContainer } from '@shared/dependencyInjection/DependencyInjectionContainer';
import { ContainerRegisteredModuleDescriptor } from '@shared/dependencyInjection/DependencyInjectionTypes';
import { getDependencyTree } from '@shared/visualServer/dependencyTree';
import { generateHtml } from '@shared/visualServer/generateHtml';

export type Method = {
  name: string;
  definition: string;
  returnStructure: TypeNode | string;
};

export type TypeNode =
  | { kind: 'primitive'; type: string }
  | { kind: 'reference'; type: string; refId: string }
  | { kind: 'array'; elementType: TypeNode }
  | { kind: 'union'; types: TypeNode[] }
  | { kind: 'object'; type: string; properties: PropertyNode[] }
  | { kind: 'enum'; type: string; members: string[] }
  | { kind: 'promise'; type: TypeNode };

export type PropertyNode = {
  name: string;
  type: TypeNode;
  optional: boolean;
};
export type EntryPointMetaData = {
  name: string;
  version: string;
  containerName: string;
  methods?: Method[];
};

type ContainerName = string;

const entryPoints = new Map<EntryPointMetaData, unknown>();
const containers = new Map<ContainerName, unknown>();
const dependencyGraph: any[] = [];

function registerContainer(name: string = '', container: unknown): void {
  containers.set(name, container);
}

function registerEntryPoint(entryPointClass: unknown, entryPointMetaData: EntryPointMetaData): void {
  entryPoints.set(entryPointMetaData, entryPointClass);
}

function generateGraphDependency(): void {
  const containersList = Array.from(containers);
  containersList.forEach((containerEntry: [string, any]) => {
    const container: DependencyInjectionContainer = containerEntry[1];
    const containerName = containerEntry[0];
    const serviceTrees: any[] = []; // Local tree for this service

    const entryPointList = Array.from(entryPoints);
    entryPointList
      .filter((entryPoint) => {
        return entryPoint[0].containerName === containerName;
      })
      .forEach((entryPoint) => {
        const entrypointMetaData = entryPoint[0];
        container.register({ serviceVersion: DependencyInjectionContainer.asValue(entrypointMetaData.version) });
        const containerRegisteredModuleDescriptors: ContainerRegisteredModuleDescriptor[] = container.listModules();
        const tree = getDependencyTree(container, entrypointMetaData, containerRegisteredModuleDescriptors);
        dependencyGraph.push(tree);
        serviceTrees.push(tree);
      });

    generateHtml(serviceTrees, containerName);
  });
}

export const visualServer = {
  registerContainer,
  registerEntryPoint,
  dependencyGraph,
  generateGraphDependency,
};