Service Classes

/**
 * Base class for metadata exploration services
 */
export abstract class BaseExplorerService {
  /**
   * Explores modules and extracts relevant metadata
   * @returns Array of metadata objects
   */
  abstract explore(): any[];
}

/**
 * Service for exploring and extracting resolver metadata from modules
 */
export class ResolversExplorerService extends BaseExplorerService {
  /**
   * Explores modules to find GraphQL resolvers
   * @param modules - Array of NestJS modules to explore
   * @returns Array of resolver metadata
   */
  exploreResolvers(modules: Module[]): ResolverMetadata[];
  
  /**
   * Extracts field resolvers from resolver classes
   * @param resolverClass - The resolver class to analyze
   * @returns Array of field resolver metadata
   */
  extractFieldResolvers(resolverClass: Type<any>): FieldResolverMetadata[];
}

import { ResolversExplorerService } from "@nestjs/graphql";

const resolversExplorer = new ResolversExplorerService();
const resolverMetadata = resolversExplorer.exploreResolvers(appModules);

/**
 * Service for exploring and extracting scalar metadata from modules
 */
export class ScalarsExplorerService extends BaseExplorerService {
  /**
   * Explores modules to find custom GraphQL scalars
   * @param modules - Array of NestJS modules to explore
   * @returns Array of scalar metadata
   */
  exploreScalars(modules: Module[]): ScalarMetadata[];
  
  /**
   * Extracts scalar definition from scalar class
   * @param scalarClass - The scalar class to analyze
   * @returns Scalar metadata
   */
  extractScalarMetadata(scalarClass: Type<any>): ScalarMetadata;
}

/**
 * Service for exploring GraphQL AST and generating type definitions
 */
export class GraphQLAstExplorer {
  /**
   * Explores GraphQL document node and generates TypeScript definitions
   * @param documentNode - GraphQL document AST node
   * @param outputPath - Path where to write generated definitions
   * @param mode - Output format mode
   */
  explore(
    documentNode: DocumentNode, 
    outputPath: string, 
    mode: GenerateOptions['outputAs']
  ): Promise<void>;
  
  /**
   * Generates TypeScript interfaces from GraphQL types
   * @param typeNode - GraphQL type definition node
   * @returns TypeScript interface definition
   */
  generateTypeDefinition(typeNode: TypeDefinitionNode): string;
}

import { GraphQLAstExplorer } from "@nestjs/graphql";
import { parse } from "graphql";

const astExplorer = new GraphQLAstExplorer();
const schema = parse(`
  type User {
    id: ID!
    name: String!
  }
`);

await astExplorer.explore(schema, './generated-types.ts', 'interface');

/**
 * Service for loading GraphQL schema definitions from files
 */
export class GraphQLTypesLoader {
  /**
   * Merges GraphQL type definitions from multiple file paths
   * @param paths - Array of file paths containing GraphQL schemas
   * @returns Merged GraphQL schema string
   */
  mergeTypesByPaths(paths: string[]): string;
  
  /**
   * Loads GraphQL schema from a single file
   * @param path - File path to GraphQL schema
   * @returns GraphQL schema string
   */
  loadSchema(path: string): string;
}

import { GraphQLTypesLoader } from "@nestjs/graphql";

const typesLoader = new GraphQLTypesLoader();
const mergedSchema = typesLoader.mergeTypesByPaths([
  './schemas/user.graphql',
  './schemas/post.graphql'
]);

/**
 * Storage for GraphQL type metadata
 */
export class TypeMetadataStorage {
  /**
   * Adds field metadata to storage
   * @param metadata - Field metadata to store
   */
  addFieldMetadata(metadata: FieldMetadata): void;
  
  /**
   * Adds class metadata to storage
   * @param metadata - Class metadata to store
   */
  addClassMetadata(metadata: ClassMetadata): void;
  
  /**
   * Compiles and returns complete metadata for a target class
   * @param target - Target class constructor
   * @returns Compiled class metadata
   */
  compileClassMetadata(target: Function): ClassMetadata;
  
  /**
   * Gets all field metadata for a specific target
   * @param target - Target class constructor
   * @returns Array of field metadata
   */
  getFieldMetadata(target: Function): FieldMetadata[];
  
  /**
   * Clears all stored metadata
   */
  clear(): void;
}

/**
 * Metadata for GraphQL resolver classes
 */
interface ResolverMetadata {
  target: Function;
  typeFn?: ReturnTypeFunc;
  isAbstract?: boolean;
  parent?: Function;
}

/**
 * Metadata for GraphQL field resolvers
 */
interface FieldResolverMetadata {
  target: Function;
  methodName: string;
  fieldName?: string;
  typeFn?: ReturnTypeFunc;
  options?: ResolveFieldOptions;
}

/**
 * Metadata for custom GraphQL scalars
 */
interface ScalarMetadata {
  target: Function;
  name: string;
  typeFn?: ReturnTypeFunc;
}

/**
 * Metadata for GraphQL fields
 */
interface FieldMetadata {
  target: Function;
  propertyKey: string;
  typeFn?: ReturnTypeFunc;
  options?: FieldOptions;
}

/**
 * Metadata for GraphQL classes (ObjectType, InputType, etc.)
 */
interface ClassMetadata {
  target: Function;
  name?: string;
  description?: string;
  isAbstract?: boolean;
  interfaces?: Function[];
  fields: FieldMetadata[];
}

/**
 * Options for generating TypeScript definitions
 */
interface GenerateOptions {
  outputAs?: 'class' | 'interface';
  outputPath?: string;
  watch?: boolean;
  debug?: boolean;
}

/**
 * NestJS module reference
 */
interface Module {
  metatype: Type<any>;
  providers: any[];
  controllers: any[];
  exports: any[];
}

import { TypeMetadataStorage } from "@nestjs/graphql";

const storage = new TypeMetadataStorage();

// Store field metadata
storage.addFieldMetadata({
  target: UserClass,
  propertyKey: 'name',
  typeFn: () => String,
  options: { nullable: false }
});

// Retrieve compiled metadata
const classMetadata = storage.compileClassMetadata(UserClass);