@rekog/mcp-nest 1.2.0 → 1.3.0

package/playground/greeting.resource.ts

@@ -0,0 +1,25 @@
+import { Injectable, Scope } from '@nestjs/common';
+import { Resource } from '../src';
+
+@Injectable({ scope: Scope.REQUEST })
+export class GreetingResource {
+  constructor() {}
+
+  @Resource({
+    name: 'hello-world',
+    description: 'A simple greeting resource',
+    mimeType: 'text/plain',
+    uri: 'mcp://hello-world/{name}',
+  })
+  sayHello({ name }) {
+    return {
+      contents: [
+        {
+          uri: 'mcp://hello-world',
+          mimeType: 'text/plain',
+          text: `Hello ${name}`,
+        },
+      ],
+    };
+  }
+}

package/playground/greeting.tool.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common';
+import { Context, Tool } from '../src';
+import { Progress } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+@Injectable()
+export class GreetingTool {
+  constructor() {}
+
+  @Tool({
+    name: 'hello-world',
+    description:
+      'Returns a greeting and simulates a long operation with progress updates',
+    parameters: z.object({
+      name: z.string().default('World'),
+    }),
+  })
+  async sayHello({ name }, context: Context) {
+    const greeting = `Hello, ${name}!`;
+
+    const totalSteps = 5;
+    for (let i = 0; i < totalSteps; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      // Send a progress update.
+      await context.reportProgress({
+        progress: (i + 1) * 20,
+        total: 100,
+      } as Progress);
+    }
+
+    return {
+      content: [{ type: 'text', text: greeting }],
+    };
+  }
+}

package/playground/server.ts

@@ -0,0 +1,25 @@
+import { NestFactory } from '@nestjs/core';
+import { Module } from '@nestjs/common';
+import { McpModule } from '../src';
+import { GreetingResource } from './greeting.resource';
+import { GreetingTool } from './greeting.tool';
+
+@Module({
+  imports: [
+    McpModule.forRoot({
+      name: 'playground-mcp-server',
+      version: '0.0.1',
+    }),
+  ],
+  providers: [GreetingResource, GreetingTool],
+})
+class AppModule {}
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3030);
+
+  console.log('MCP server started on port 3030');
+}
+
+void bootstrap();

package/tests/mcp-resource.e2e.spec.ts

@@ -0,0 +1,179 @@
+import { INestApplication } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Injectable } from '@nestjs/common';
+import { McpModule } from '../src/mcp.module';
+import { createMCPClient } from './utils';
+import { Resource } from '../src';
+
+@Injectable()
+export class GreetingToolResource {
+  constructor() {}
+
+  @Resource({
+    name: 'hello-world',
+    description: 'A simple greeting resource',
+    mimeType: 'text/plain',
+    uri: 'mcp://hello-world',
+  })
+  async sayHello({ uri }) {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: 'text/plain',
+          text: 'Hello World',
+        },
+      ],
+    };
+  }
+
+  @Resource({
+    name: 'hello-world-dynamic',
+    description: 'A simple greeting dynamic resource',
+    mimeType: 'text/plain',
+    uri: 'mcp://hello-world-dynamic/{userName}',
+  })
+  async sayHelloDynamic({ uri, userName }) {
+    return {
+      contents: [
+        {
+          uri: uri,
+          mimeType: 'text/plain',
+          text: `Hello ${userName}`,
+        },
+      ],
+    };
+  }
+
+  @Resource({
+    name: 'hello-world-dynamic-multiple-paths',
+    description: 'A simple greeting dynamic resource with multiple paths',
+    mimeType: 'text/plain',
+    uri: 'mcp://hello-world-dynamic-multiple-paths/{userId}/{userName}',
+  })
+  async sayHelloMultiplePathsDynamic({ uri, userId, userName }) {
+    return {
+      contents: [
+        {
+          uri: uri,
+          mimeType: 'text/plain',
+          text: `Hello ${userName} from ${userId}`,
+        },
+      ],
+    };
+  }
+
+  @Resource({
+    name: 'hello-world-dynamic-multiple-paths-error',
+    description: 'A simple greeting dynamic resource with multiple paths',
+    mimeType: 'text/plain',
+    uri: 'mcp://hello-world-dynamic-multiple-paths-error/{userId}/{userName}',
+  })
+  async sayHelloMultiplePathsDynamicError() {
+    throw new Error('any error');
+  }
+}
+
+describe('E2E: MCP Resource Server', () => {
+  let app: INestApplication;
+  let testPort: number;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [
+        McpModule.forRoot({
+          name: 'test-mcp-server',
+          version: '0.0.1',
+          guards: [],
+        }),
+      ],
+      providers: [GreetingToolResource],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.listen(0);
+
+    const server = app.getHttpServer();
+    testPort = server.address().port;
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('should list resources', async () => {
+    const client = await createMCPClient(testPort);
+    const resources = await client.listResources();
+
+    expect(resources.resources.find((r) => r.name === 'hello-world')).toEqual({
+      name: 'hello-world',
+      uri: 'mcp://hello-world',
+      description: 'A simple greeting resource',
+      mimeType: 'text/plain',
+    });
+
+    expect(
+      resources.resources.find((r) => r.name === 'hello-world-dynamic'),
+    ).toEqual({
+      name: 'hello-world-dynamic',
+      uri: 'mcp://hello-world-dynamic/{userName}',
+      description: 'A simple greeting dynamic resource',
+      mimeType: 'text/plain',
+    });
+
+    await client.close();
+  });
+
+  it('should call the dynamic resource', async () => {
+    const client = await createMCPClient(testPort);
+
+    const result: any = await client.readResource({
+      uri: 'mcp://hello-world-dynamic/Raphael_John',
+    });
+
+    expect(result.contents[0].uri).toBe(
+      'mcp://hello-world-dynamic/Raphael_John',
+    );
+    expect(result.contents[0].mimeType).toBe('text/plain');
+    expect(result.contents[0].text).toBe('Hello Raphael_John');
+
+    await client.close();
+  });
+
+  it('should call the dynamic resource with multiple paths', async () => {
+    const client = await createMCPClient(testPort);
+
+    const result: any = await client.readResource({
+      uri: 'mcp://hello-world-dynamic-multiple-paths/123/Raphael_John',
+    });
+
+    expect(result.contents[0].uri).toBe(
+      'mcp://hello-world-dynamic-multiple-paths/123/Raphael_John',
+    );
+    expect(result.contents[0].mimeType).toBe('text/plain');
+    expect(result.contents[0].text).toBe('Hello Raphael_John from 123');
+
+    await client.close();
+  });
+
+  it('should return an error when the resource is not found', async () => {
+    const client = await createMCPClient(testPort);
+
+    const result: any = await client.readResource({
+      uri: 'mcp://hello-world-dynamic-multiple-paths-error/123/Raphael_John',
+    });
+
+    expect(result).toEqual({
+      contents: [
+        {
+          uri: 'mcp://hello-world-dynamic-multiple-paths-error/123/Raphael_John',
+          mimeType: 'text/plain',
+          text: 'any error',
+        },
+      ],
+      isError: true,
+    });
+
+    await client.close();
+  });
+});

package/tests/{mcp-auth.e2e.spec.ts → mcp-tool-auth.e2e.spec.ts}

@@ -1,28 +1,30 @@
-import { INestApplication, Injectable } from "@nestjs/common";
-import { Test, TestingModule } from "@nestjs/testing";
-import { z } from "zod";
-import { Context, Tool } from "../src";
-import { McpModule } from "../src/mcp.module";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { Progress } from "@modelcontextprotocol/sdk/types.js";
-import { CanActivate, ExecutionContext } from "@nestjs/common";
+import { INestApplication, Injectable } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { z } from 'zod';
+import { Context, Tool } from '../src';
+import { McpModule } from '../src/mcp.module';
+import { Progress } from '@modelcontextprotocol/sdk/types.js';
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { createMCPClient } from './utils';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 
 // Mock authentication guard
 class MockAuthGuard implements CanActivate {
   canActivate(context: ExecutionContext): boolean {
     const request = context.switchToHttp().getRequest();
 
-
-    if (request.headers.authorization && request.headers.authorization.includes("token-xyz")) {
+    if (
+      request.headers.authorization &&
+      request.headers.authorization.includes('token-xyz')
+    ) {
       request.user = {
-        id: "user123",
-        name: "Test User",
+        id: 'user123',
+        name: 'Test User',
         orgMemberships: [
           {
-            orgId: "org123",
+            orgId: 'org123',
             organization: {
-              name: "Auth Test Org",
+              name: 'Auth Test Org',
             },
           },
         ],
@@ -30,6 +32,7 @@ class MockAuthGuard implements CanActivate {
 
       return true;
     }
+
     return false;
   }
 }
@@ -38,18 +41,18 @@ class MockAuthGuard implements CanActivate {
 @Injectable()
 class MockUserRepository {
   async findOne() {
-    return {
-      id: "userRepo123",
-      name: "Repository User",
+    return Promise.resolve({
+      id: 'userRepo123',
+      name: 'Repository User',
       orgMemberships: [
         {
-          orgId: "org123",
+          orgId: 'org123',
           organization: {
-            name: "Repository Org",
+            name: 'Repository Org',
           },
         },
       ],
-    };
+    });
   }
 }
 
@@ -59,10 +62,10 @@ export class AuthGreetingTool {
   constructor(private readonly userRepository: MockUserRepository) {}
 
   @Tool({
-    name: "auth-hello-world",
-    description: "A sample tool that accesses the authenticated user",
+    name: 'auth-hello-world',
+    description: 'A sample tool that accesses the authenticated user',
     parameters: z.object({
-      name: z.string().default("World"),
+      name: z.string().default('World'),
     }),
   })
   async sayHello({ name }, context: Context, request: Request & { user: any }) {
@@ -71,15 +74,13 @@ export class AuthGreetingTool {
     const authUser = request.user; // Authenticated user from the request
 
     // Construct greeting using both data sources
-    const greeting = `Hello, ${name}! I'm ${authUser.name} from ${
-      authUser.orgMemberships[0].organization.name
-    }. Repository user is ${repoUser.name}.`;
+    const greeting = `Hello, ${name}! I'm ${authUser.name} from ${authUser.orgMemberships[0].organization.name}. Repository user is ${repoUser.name}.`;
 
     // Report progress for demonstration
     for (let i = 0; i < 5; i++) {
       await new Promise((resolve) => setTimeout(resolve, 200));
       await context.reportProgress({
-        progress: (i+1) * 20,
+        progress: (i + 1) * 20,
         total: 100,
       } as Progress);
     }
@@ -87,7 +88,7 @@ export class AuthGreetingTool {
     return {
       content: [
         {
-          type: "text",
+          type: 'text',
           text: greeting,
         },
       ],
@@ -95,7 +96,7 @@ export class AuthGreetingTool {
   }
 }
 
-describe("E2E: MCP Server with Authentication", () => {
+describe('E2E: MCP Server Tool with Authentication', () => {
   let app: INestApplication;
   let testPort: number;
 
@@ -103,18 +104,21 @@ describe("E2E: MCP Server with Authentication", () => {
     const moduleFixture: TestingModule = await Test.createTestingModule({
       imports: [
         McpModule.forRoot({
-          name: "test-auth-mcp-server",
-          version: "0.0.1",
+          name: 'test-auth-mcp-server',
+          version: '0.0.1',
           // Specify the MockAuthGuard to protect the messages endpoint
           guards: [MockAuthGuard],
           capabilities: {
+            resources: {},
+            resourceTemplates: {},
             tools: {
-              "auth-hello-world": {
-                description: "A sample tool that accesses the authenticated user",
+              'auth-hello-world': {
+                description:
+                  'A sample tool that accesses the authenticated user',
                 input: {
                   name: {
-                    type: "string",
-                    default: "World",
+                    type: 'string',
+                    default: 'World',
                   },
                 },
               },
@@ -136,53 +140,43 @@ describe("E2E: MCP Server with Authentication", () => {
     await app.close();
   });
 
-  it("should list tools", async () => {
-    const client = new Client(
-      { name: "example-client", version: "1.0.0" },
-      { capabilities: {} },
-    );
-    const sseUrl = new URL(`http://localhost:${testPort}/sse`);
-    const transport = new SSEClientTransport(sseUrl, {
+  it('should list tools', async () => {
+    const client = await createMCPClient(testPort, {
       requestInit: {
         headers: {
-          Authorization: 'Bearer token-xyz'
-        }
-      }
+          Authorization: 'Bearer token-xyz',
+        },
+      },
     });
-    await client.connect(transport);
     const tools = await client.listTools();
 
     // Verify that the authenticated tool is available
     expect(tools.tools.length).toBeGreaterThan(0);
-    expect(tools.tools.find((t) => t.name === "auth-hello-world")).toBeDefined();
+    expect(
+      tools.tools.find((t) => t.name === 'auth-hello-world'),
+    ).toBeDefined();
 
     await client.close();
   });
 
   it('should inject authentication context into the tool', async () => {
-    const client = new Client(
-      { name: "example-client", version: "1.0.0" },
-      { capabilities: {} },
-    );
-    const sseUrl = new URL(`http://localhost:${testPort}/sse`);
-    const transport = new SSEClientTransport(sseUrl, {
+    const client = await createMCPClient(testPort, {
       requestInit: {
         headers: {
-          Authorization: 'Bearer token-xyz'
-        }
-      }
+          Authorization: 'Bearer token-xyz',
+        },
+      },
     });
-    await client.connect(transport);
 
     let progressCount = 0;
     const result: any = await client.callTool(
       {
-        name: "auth-hello-world",
-        arguments: { name: "Authenticated User" },
+        name: 'auth-hello-world',
+        arguments: { name: 'Authenticated User' },
       },
       undefined,
       {
-        onprogress: (progress) => {
+        onprogress: () => {
           progressCount++;
         },
       },
@@ -192,40 +186,35 @@ describe("E2E: MCP Server with Authentication", () => {
     expect(progressCount).toBeGreaterThan(0);
 
     // Verify that authentication context was available to the tool
-    expect(result.content[0].type).toBe("text");
-    expect(result.content[0].text).toContain("Auth Test Org");
-    expect(result.content[0].text).toContain("Test User");
-    expect(result.content[0].text).toContain("Repository user is Repository User");
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('Auth Test Org');
+    expect(result.content[0].text).toContain('Test User');
+    expect(result.content[0].text).toContain(
+      'Repository user is Repository User',
+    );
 
     await client.close();
   });
 
   it('should reject unauthenticated connections', async () => {
-    const client = new Client(
-      { name: "example-client", version: "1.0.0" },
-      { capabilities: {} },
-    );
-    const sseUrl = new URL(`http://localhost:${testPort}/sse`);
-
-    // Using invalid token
-    const transport = new SSEClientTransport(sseUrl, {
-      requestInit: {
-        headers: {
-          Authorization: 'Bearer invalid-token'
-        }
-      }
-    });
-
     // Connection should be rejected
+    let client: Client | undefined;
     try {
-      await client.connect(transport);
+      client = await createMCPClient(testPort, {
+        requestInit: {
+          headers: {
+            Authorization: 'Bearer invalid-token',
+          },
+        },
+      });
+
       // If we get here, the test should fail
       fail('Connection should have been rejected');
     } catch (error) {
       // We expect an error to be thrown when authentication fails
       expect(error).toBeDefined();
     } finally {
-      await client.close();
+      await client?.close();
     }
   });
-});
+});