@nestjs-mcp/server 0.1.0-alpha.4

package/src/mcp.module.ts

@@ -0,0 +1,233 @@
+import { Implementation } from '@modelcontextprotocol/sdk/types';
+import { DynamicModule, Module, Provider, Type } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+
+import { SseController, SseService } from './controllers/sse';
+import {
+  StreamableController,
+  StreamableService,
+} from './controllers/streamable';
+import {
+  McpFeatureOptions,
+  McpLoggingOptions,
+  McpModuleOptions,
+  McpModuleTransportOptions,
+  ServerOptions,
+} from './interfaces/mcp-server-options.interface';
+import { DiscoveryService } from './registry/discovery.service';
+import { McpLoggerService } from './registry/logger.service';
+import { RegistryService } from './registry/registry.service';
+
+@Module({
+  imports: [DiscoveryModule],
+  providers: [RegistryService, DiscoveryService, McpLoggerService],
+})
+export class McpModule {
+  /**
+   * Helper: Get active transport controllers and providers
+   */
+  private static getActiveTransportControllersAndProviders(
+    transports?: McpModuleTransportOptions,
+  ) {
+    const controllers = new Set<Type<any>>();
+    const providers = new Set<Provider>();
+
+    // Transport configurations
+    const STREAMABLE_TRANSPORT = {
+      controller: StreamableController,
+      service: StreamableService,
+    };
+
+    const SSE_TRANSPORT = {
+      controller: SseController,
+      service: SseService,
+    };
+
+    // Default configuration
+    const defaultTransports: McpModuleTransportOptions = {
+      streamable: { enabled: true },
+      sse: { enabled: true },
+    };
+
+    // Merge default with provided transports
+    const config = {
+      streamable: {
+        ...defaultTransports.streamable,
+        ...(transports?.streamable ?? {}),
+      },
+      sse: {
+        ...defaultTransports.sse,
+        ...(transports?.sse ?? {}),
+      },
+    };
+
+    // Add controllers and providers based on enabled transports
+    if (config.streamable.enabled) {
+      controllers.add(STREAMABLE_TRANSPORT.controller);
+      providers.add(STREAMABLE_TRANSPORT.service);
+    }
+
+    if (config.sse.enabled) {
+      controllers.add(SSE_TRANSPORT.controller);
+      providers.add(SSE_TRANSPORT.service);
+    }
+
+    return {
+      controllers: Array.from(controllers),
+      providers: Array.from(providers),
+    };
+  }
+
+  /**
+   * Helper to build server info, options, and logging config
+   */
+  private static buildServerConfig(options: McpModuleOptions) {
+    const serverInfo: Implementation = {
+      name: options.name,
+      version: options.version,
+    };
+    const serverOptions: ServerOptions = {
+      instructions: options?.instructions,
+      capabilities: options?.capabilities,
+      ...(options?.protocolOptions || {}),
+    };
+    const loggingOptions: McpLoggingOptions = {
+      enabled: options.logging?.enabled !== false,
+      level: options.logging?.level || 'verbose',
+    };
+    return { serverInfo, serverOptions, loggingOptions };
+  }
+
+  /**
+   * Configures the MCP module with global options
+   *
+   * @param options Configuration options for the MCP server
+   * @returns Dynamic module configuration
+   */
+  static forRoot(options: McpModuleOptions): DynamicModule {
+    const imports = options.imports || [];
+    const { controllers, providers } =
+      this.getActiveTransportControllersAndProviders(options.transports);
+    const allProviders = [...(options.providers || []), ...providers];
+    const { serverInfo, serverOptions, loggingOptions } =
+      this.buildServerConfig(options);
+    return {
+      module: McpModule,
+      imports,
+      controllers,
+      providers: [
+        ...allProviders,
+        {
+          provide: 'MCP_SERVER_OPTIONS',
+          useValue: {
+            serverInfo,
+            options: serverOptions,
+            logging: loggingOptions,
+          },
+        },
+        {
+          provide: 'MCP_LOGGING_OPTIONS',
+          useValue: loggingOptions,
+        },
+        {
+          provide: 'MCP_TRANSPORT_OPTIONS',
+          useValue: options.transports,
+        },
+      ],
+      global: true,
+    };
+  }
+
+  /**
+   * Configures the MCP module with global options and ConfigModule support
+   * Allows using environment variables and centralized configurations
+   *
+   * @param options Configuration options for the MCP server
+   * @returns Dynamic module configuration
+   */
+  static forRootAsync(options: {
+    imports?: any[];
+    useFactory: (
+      ...args: unknown[]
+    ) => Promise<McpModuleOptions> | McpModuleOptions;
+    inject?: any[];
+  }): DynamicModule {
+    const { imports = [], useFactory, inject = [] } = options;
+    const safeInject = Array.isArray(inject) ? inject : [];
+    const safeImports = Array.isArray(imports) ? imports : [];
+    const providers = [
+      {
+        provide: 'MCP_SERVER_OPTIONS',
+        useFactory: async (...args: unknown[]) => {
+          const mcpOptions = await useFactory(...args);
+          const { serverInfo, serverOptions, loggingOptions } =
+            this.buildServerConfig(mcpOptions);
+          return {
+            serverInfo,
+            options: serverOptions,
+            logging: loggingOptions,
+          };
+        },
+        inject: safeInject,
+      },
+      {
+        provide: 'MCP_LOGGING_OPTIONS',
+        useFactory: async (...args: unknown[]) => {
+          const mcpOptions = await useFactory(...args);
+          return {
+            enabled: mcpOptions.logging?.enabled !== false,
+            level: mcpOptions.logging?.level || 'verbose',
+          };
+        },
+        inject: safeInject,
+      },
+    ];
+    const asyncControllersFactory = async (...args: unknown[]) => {
+      const mcpOptions = await useFactory(...args);
+      return this.getActiveTransportControllersAndProviders(
+        mcpOptions.transports,
+      ).controllers;
+    };
+    const asyncProvidersFactory = async (...args: unknown[]) => {
+      const mcpOptions = await useFactory(...args);
+      const { providers } = this.getActiveTransportControllersAndProviders(
+        mcpOptions.transports,
+      );
+      return [...(mcpOptions.providers || []), ...providers];
+    };
+    return {
+      module: McpModule,
+      imports: safeImports,
+      controllers: [], // Will be resolved at runtime by NestJS
+      providers: [
+        ...providers,
+        {
+          provide: '__MCP_ASYNC_CONTROLLERS__',
+          useFactory: asyncControllersFactory,
+          inject: safeInject,
+        },
+        {
+          provide: '__MCP_ASYNC_PROVIDERS__',
+          useFactory: asyncProvidersFactory,
+          inject: safeInject,
+        },
+      ],
+      global: true,
+    };
+  }
+
+  /**
+   * Registers feature-specific capabilities like tools, prompts, and resources
+   * through dedicated service providers
+   *
+   * @param options Configuration options for the feature module
+   * @returns A dynamic module configuration
+   */
+  // TODO: Implement specific Module options
+
+  static forFeature(_options?: McpFeatureOptions): DynamicModule {
+    return {
+      module: McpModule,
+    };
+  }
+}

package/src/mcp.service.spec.ts

@@ -0,0 +1,28 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { SseService } from './controllers/sse';
+import { StreamableService } from './controllers/streamable';
+import { McpModule } from './mcp.module';
+describe('NestjsMcpServerService', () => {
+  let streamableService: StreamableService;
+  let sseService: SseService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [
+        McpModule.forRoot({
+          name: 'test',
+          version: '1.0.0',
+        }),
+      ],
+    }).compile();
+
+    streamableService = module.get<StreamableService>(StreamableService);
+    sseService = module.get<SseService>(SseService);
+  });
+
+  it('should be defined', () => {
+    expect(streamableService).toBeDefined();
+    expect(sseService).toBeDefined();
+  });
+});

package/src/registry/discovery.service.ts

@@ -0,0 +1,116 @@
+import { Injectable } from '@nestjs/common';
+import {
+  MetadataScanner,
+  DiscoveryService as NestDiscoveryService,
+  Reflector,
+} from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+
+export interface MethodWithMetadata<T = unknown> {
+  method: string;
+  metadata: T;
+  handler: (...args: any[]) => any;
+  instance: object;
+}
+
+type ProviderInstance = Record<string, unknown>;
+
+@Injectable()
+export class DiscoveryService {
+  constructor(
+    private readonly discoveryService: NestDiscoveryService,
+    private readonly metadataScanner: MetadataScanner,
+    private readonly reflector: Reflector,
+  ) {}
+
+  /**
+   * Get all methods with specific metadata from all providers (now scans all @Injectable, not just @McpProvider)
+   */
+  public getAllMethodsWithMetadata<T = unknown>(
+    metadataKey: string,
+  ): MethodWithMetadata<T>[] {
+    const providers = this.discoveryService.getProviders();
+    const result: MethodWithMetadata<T>[] = [];
+
+    // Scan ALL providers, not just those with MCP_PROVIDER
+    for (const provider of providers) {
+      if (!provider.instance) {
+        continue;
+      }
+
+      const methods = this.getMethodsWithMetadataFromProvider<T>(
+        provider,
+        metadataKey,
+      );
+
+      if (methods.length > 0) {
+        result.push(...methods);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get all methods with a specific metadata from a single provider.
+   */
+  public getMethodsWithMetadataFromProvider<T = unknown>(
+    provider: InstanceWrapper,
+    metadataKey: string,
+  ): MethodWithMetadata<T>[] {
+    if (!provider.instance) {
+      return [];
+    }
+
+    const instance = provider.instance as ProviderInstance;
+    const instancePrototype = Object.getPrototypeOf(instance) as Record<
+      string,
+      unknown
+    >;
+
+    if (!instancePrototype) {
+      return [];
+    }
+
+    const methodNames =
+      this.metadataScanner.getAllMethodNames(instancePrototype);
+    const result: MethodWithMetadata<T>[] = [];
+
+    for (const methodName of methodNames) {
+      // Removed hasOwnProperty check to allow inherited methods
+      const methodFunction = instancePrototype[methodName];
+      if (typeof methodFunction !== 'function') {
+        continue;
+      }
+
+      const metadata = this.reflector.get<T>(metadataKey, methodFunction);
+
+      if (metadata) {
+        const handlerProperty = instance[methodName];
+
+        if (typeof handlerProperty !== 'function') {
+          continue;
+        }
+
+        const handler = ((...args: unknown[]): unknown => {
+          return handlerProperty.apply(instance, args);
+        }) as (...args: any[]) => any;
+
+        // Preserve the original method name
+        Object.defineProperty(handler, 'name', {
+          value: methodName,
+          writable: false,
+        });
+
+        result.push({
+          method: methodName,
+          metadata: metadata as T,
+          handler,
+          instance,
+        });
+      }
+    }
+
+    return result;
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1,2 @@
+export * from './discovery.service';
+export * from './registry.service';

package/src/registry/logger.service.ts

@@ -0,0 +1,143 @@
+import {
+  Inject,
+  Injectable,
+  Logger,
+  LoggerService,
+  Optional,
+} from '@nestjs/common';
+
+import { McpLoggingOptions } from '../interfaces/mcp-server-options.interface';
+
+/**
+ * Servicio especializado de logging para el servidor MCP
+ */
+@Injectable()
+export class McpLoggerService implements LoggerService {
+  private readonly logger: Logger;
+  private readonly options: Required<McpLoggingOptions>;
+
+  constructor(
+    @Optional() @Inject('MCP_LOGGING_OPTIONS') options?: McpLoggingOptions,
+  ) {
+    this.options = {
+      enabled: options?.enabled !== false, // Habilitado por defecto
+      level: options?.level || 'verbose',
+    };
+
+    this.logger = new Logger('MCP');
+  }
+
+  /**
+   * Registra un mensaje de nivel debug
+   */
+  debug(message: string, context?: string): void {
+    if (
+      !this.options.enabled ||
+      this.getLevelValue(this.options.level) > this.getLevelValue('debug')
+    ) {
+      return;
+    }
+
+    const formattedContext = this.formatContext(context);
+    this.logger.debug(message, formattedContext);
+  }
+
+  /**
+   * Registra un mensaje de nivel verbose (detallado)
+   */
+  verbose(message: string, context?: string): void {
+    if (
+      !this.options.enabled ||
+      this.getLevelValue(this.options.level) > this.getLevelValue('verbose')
+    ) {
+      return;
+    }
+
+    const formattedContext = this.formatContext(context);
+    this.logger.verbose(message, formattedContext);
+  }
+
+  /**
+   * Registra un mensaje de nivel log (información)
+   */
+  log(message: string, context?: string): void {
+    if (
+      !this.options.enabled ||
+      this.getLevelValue(this.options.level) > this.getLevelValue('log')
+    ) {
+      return;
+    }
+
+    const formattedContext = this.formatContext(context);
+    this.logger.log(message, formattedContext);
+  }
+
+  /**
+   * Registra un mensaje de nivel warn (advertencia)
+   */
+  warn(message: string, context?: string): void {
+    if (
+      !this.options.enabled ||
+      this.getLevelValue(this.options.level) > this.getLevelValue('warn')
+    ) {
+      return;
+    }
+
+    const formattedContext = this.formatContext(context);
+    this.logger.warn(message, formattedContext);
+  }
+
+  /**
+   * Registra un mensaje de nivel error
+   */
+  error(message: string, trace?: string, context?: string): void {
+    if (
+      !this.options.enabled ||
+      this.getLevelValue(this.options.level) > this.getLevelValue('error')
+    ) {
+      return;
+    }
+
+    const formattedContext = this.formatContext(context);
+    this.logger.error(message, trace, formattedContext);
+  }
+
+  /**
+   * Método para determinar si el logging está habilitado
+   */
+  isEnabled(): boolean {
+    return this.options.enabled;
+  }
+
+  /**
+   * Método para obtener el nivel actual de logging
+   */
+  getLevel(): string {
+    return this.options.level;
+  }
+
+  /**
+   * Formatea el contexto para añadirle el prefijo '@mcp'
+   */
+  private formatContext(context?: string): string {
+    if (!context) {
+      return '@mcp';
+    }
+    return `@mcp:${context}`;
+  }
+
+  /**
+   * Convierte un nivel de log a un valor numérico para comparaciones
+   */
+  private getLevelValue(level: string): number {
+    const levels: Record<string, number> = {
+      debug: 0,
+      verbose: 1,
+      log: 2,
+      warn: 3,
+      error: 4,
+    };
+
+    return levels[level] ?? 2; // Por defecto, nivel 'log'
+  }
+}