@rekog/mcp-nest 1.9.10 → 2.0.0-alpha.0

package/src/authz/stores/memory-store.service.spec.ts

@@ -1,475 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { MemoryStore } from './memory-store.service';
-import { OAuthClient, AuthorizationCode } from './oauth-store.interface';
-import { OAuthSession } from '../providers/oauth-provider.interface';
-
-describe('MemoryStore', () => {
-  let service: MemoryStore;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [MemoryStore],
-    }).compile();
-
-    service = module.get<MemoryStore>(MemoryStore);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-
-  describe('generateClientId', () => {
-    it('should generate consistent client IDs for identical objects', () => {
-      const client1: Partial<OAuthClient> = {
-        client_name: 'MCP Inspector',
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
-      };
-
-      const client2: Partial<OAuthClient> = {
-        client_name: 'MCP Inspector',
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
-      };
-
-      const id1 = service.generateClientId(client1 as OAuthClient);
-      const id2 = service.generateClientId(client2 as OAuthClient);
-
-      expect(id1).toBe(id2);
-    });
-
-    it('should generate consistent client IDs regardless of property order', () => {
-      // First object with properties in one order
-      const clientJson1 = `{
-        "client_name": "MCP Inspector",
-        "client_uri": "https://github.com/modelcontextprotocol/inspector",
-        "redirect_uris": ["http://localhost:6274/oauth/callback"],
-        "token_endpoint_auth_method": "none",
-        "grant_types": ["authorization_code", "refresh_token"],
-        "response_types": ["code"]
-      }`;
-
-      // Second object with properties in different order
-      const clientJson2 = `{
-        "response_types": ["code"],
-        "grant_types": ["authorization_code", "refresh_token"],
-        "token_endpoint_auth_method": "none",
-        "redirect_uris": ["http://localhost:6274/oauth/callback"],
-        "client_uri": "https://github.com/modelcontextprotocol/inspector",
-        "client_name": "MCP Inspector"
-      }`;
-
-      const client1 = JSON.parse(clientJson1) as OAuthClient;
-      const client2 = JSON.parse(clientJson2) as OAuthClient;
-
-      const id1 = service.generateClientId(client1);
-      const id2 = service.generateClientId(client2);
-
-      expect(id1).toBe(id2);
-    });
-
-    it('should generate consistent client IDs regardless of array order', () => {
-      // First object with arrays in one order
-      const clientJson1 = `{
-        "client_name": "MCP Inspector",
-        "client_uri": "https://github.com/modelcontextprotocol/inspector",
-        "redirect_uris": [
-          "http://localhost:6274/oauth/callback",
-          "http://localhost:8080/callback",
-          "http://127.0.0.1:3000/auth"
-        ],
-        "token_endpoint_auth_method": "none",
-        "grant_types": [
-          "authorization_code",
-          "refresh_token",
-          "client_credentials"
-        ],
-        "response_types": ["code", "token"]
-      }`;
-
-      // Second object with arrays in different order
-      const clientJson2 = `{
-        "client_name": "MCP Inspector",
-        "client_uri": "https://github.com/modelcontextprotocol/inspector",
-        "redirect_uris": [
-          "http://127.0.0.1:3000/auth",
-          "http://localhost:6274/oauth/callback",
-          "http://localhost:8080/callback"
-        ],
-        "token_endpoint_auth_method": "none",
-        "grant_types": ["client_credentials", "authorization_code", "refresh_token"],
-        "response_types": ["token", "code"]
-      }`;
-
-      const client1 = JSON.parse(clientJson1) as OAuthClient;
-      const client2 = JSON.parse(clientJson2) as OAuthClient;
-
-      const id1 = service.generateClientId(client1);
-      const id2 = service.generateClientId(client2);
-
-      expect(id1).toBe(id2);
-    });
-
-    it('should generate consistent client IDs regardless of both property and array order', () => {
-      // First object with mixed ordering
-      const clientJson1 = `{
-        "grant_types": ["refresh_token", "authorization_code"],
-        "client_name": "MCP Inspector",
-        "response_types": ["code"],
-        "redirect_uris": [
-          "http://localhost:8080/callback",
-          "http://localhost:6274/oauth/callback"
-        ],
-        "token_endpoint_auth_method": "none",
-        "client_uri": "https://github.com/modelcontextprotocol/inspector"
-      }`;
-
-      // Second object with different mixed ordering
-      const clientJson2 = `{
-        "client_uri": "https://github.com/modelcontextprotocol/inspector",
-        "token_endpoint_auth_method": "none",
-        "redirect_uris": [
-          "http://localhost:6274/oauth/callback",
-          "http://localhost:8080/callback"
-        ],
-        "response_types": ["code"],
-        "client_name": "MCP Inspector",
-        "grant_types": ["authorization_code", "refresh_token"]
-      }`;
-
-      const client1 = JSON.parse(clientJson1) as OAuthClient;
-      const client2 = JSON.parse(clientJson2) as OAuthClient;
-
-      const id1 = service.generateClientId(client1);
-      const id2 = service.generateClientId(client2);
-
-      expect(id1).toBe(id2);
-    });
-
-    it('should generate different client IDs for different objects', () => {
-      const client1: Partial<OAuthClient> = {
-        client_name: 'MCP Inspector',
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
-      };
-
-      const client2: Partial<OAuthClient> = {
-        client_name: 'Different App', // Changed client name
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
-      };
-
-      const id1 = service.generateClientId(client1 as OAuthClient);
-      const id2 = service.generateClientId(client2 as OAuthClient);
-
-      expect(id1).not.toBe(id2);
-    });
-
-    it('should generate different client IDs when array contents differ', () => {
-      const client1: Partial<OAuthClient> = {
-        client_name: 'MCP Inspector',
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
-      };
-
-      const client2: Partial<OAuthClient> = {
-        client_name: 'MCP Inspector',
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code'], // Removed 'refresh_token'
-        response_types: ['code'],
-      };
-
-      const id1 = service.generateClientId(client1 as OAuthClient);
-      const id2 = service.generateClientId(client2 as OAuthClient);
-
-      expect(id1).not.toBe(id2);
-    });
-
-    it('should include normalized client name in the generated ID', () => {
-      const client: Partial<OAuthClient> = {
-        client_name: 'MCP Inspector!@#', // Special characters
-        client_uri: 'https://github.com/modelcontextprotocol/inspector',
-        redirect_uris: ['http://localhost:6274/oauth/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code', 'refresh_token'],
-        response_types: ['code'],
-      };
-
-      const clientId = service.generateClientId(client as OAuthClient);
-
-      // Should start with normalized name (lowercase, alphanumeric only)
-      expect(clientId).toMatch(/^mcpinspector_[a-f0-9]{16}$/);
-    });
-
-    it('should generate IDs with consistent format', () => {
-      const client: Partial<OAuthClient> = {
-        client_name: 'Test App',
-        client_uri: 'https://example.com',
-        redirect_uris: ['http://localhost:3000/callback'],
-        token_endpoint_auth_method: 'none',
-        grant_types: ['authorization_code'],
-        response_types: ['code'],
-      };
-
-      const clientId = service.generateClientId(client as OAuthClient);
-
-      // Should match pattern: normalizedname_16hexchars
-      expect(clientId).toMatch(/^[a-z0-9]+_[a-f0-9]{16}$/);
-
-      // Should be consistent across multiple calls
-      const clientId2 = service.generateClientId(client as OAuthClient);
-      expect(clientId).toBe(clientId2);
-    });
-  });
-
-  describe('Client Management', () => {
-    const mockClient: OAuthClient = {
-      client_id: 'test-client-id',
-      client_name: 'Test Client',
-      client_description: 'A test OAuth client',
-      logo_uri: 'https://example.com/logo.png',
-      client_uri: 'https://example.com',
-      developer_name: 'Test Developer',
-      developer_email: 'test@example.com',
-      redirect_uris: ['http://localhost:3000/callback'],
-      grant_types: ['authorization_code', 'refresh_token'],
-      response_types: ['code'],
-      token_endpoint_auth_method: 'none',
-      created_at: new Date(),
-      updated_at: new Date(),
-    };
-
-    describe('storeClient', () => {
-      it('should store a client and return it', async () => {
-        const result = await service.storeClient(mockClient);
-        expect(result).toEqual(mockClient);
-      });
-
-      it('should allow retrieving the stored client', async () => {
-        await service.storeClient(mockClient);
-        const retrieved = await service.getClient(mockClient.client_id);
-        expect(retrieved).toEqual(mockClient);
-      });
-
-      it('should overwrite existing client with same ID', async () => {
-        await service.storeClient(mockClient);
-
-        const updatedClient = { ...mockClient, client_name: 'Updated Client' };
-        await service.storeClient(updatedClient);
-
-        const retrieved = await service.getClient(mockClient.client_id);
-        expect(retrieved?.client_name).toBe('Updated Client');
-      });
-    });
-
-    describe('getClient', () => {
-      it('should return undefined for non-existent client', async () => {
-        const result = await service.getClient('non-existent-id');
-        expect(result).toBeUndefined();
-      });
-
-      it('should return the correct client when it exists', async () => {
-        await service.storeClient(mockClient);
-        const result = await service.getClient(mockClient.client_id);
-        expect(result).toEqual(mockClient);
-      });
-    });
-
-    describe('findClient', () => {
-      it('should return undefined for non-existent client name', async () => {
-        const result = await service.findClient('Non-existent Client');
-        expect(result).toBeUndefined();
-      });
-
-      it('should find client by exact name match', async () => {
-        await service.storeClient(mockClient);
-        const result = await service.findClient(mockClient.client_name);
-        expect(result).toEqual(mockClient);
-      });
-
-      it('should be case sensitive', async () => {
-        await service.storeClient(mockClient);
-        const result = await service.findClient(
-          mockClient.client_name.toUpperCase(),
-        );
-        expect(result).toBeUndefined();
-      });
-
-      it('should return first match when multiple clients exist', async () => {
-        const client1 = { ...mockClient, client_id: 'client-1' };
-        const client2 = {
-          ...mockClient,
-          client_id: 'client-2',
-          client_name: 'Different Client',
-        };
-
-        await service.storeClient(client1);
-        await service.storeClient(client2);
-
-        const result = await service.findClient(client1.client_name);
-        expect(result).toEqual(client1);
-      });
-    });
-  });
-
-  describe('Authorization Code Management', () => {
-    const mockAuthCode: AuthorizationCode = {
-      code: 'test-auth-code',
-      user_id: 'user-123',
-      client_id: 'client-123',
-      redirect_uri: 'http://localhost:3000/callback',
-      code_challenge: 'test-challenge',
-      code_challenge_method: 'S256',
-      expires_at: Date.now() + 600000, // 10 minutes from now
-    };
-
-    describe('storeAuthCode', () => {
-      it('should store an authorization code', async () => {
-        await service.storeAuthCode(mockAuthCode);
-        const retrieved = await service.getAuthCode(mockAuthCode.code);
-        expect(retrieved).toEqual(mockAuthCode);
-      });
-
-      it('should overwrite existing code with same value', async () => {
-        await service.storeAuthCode(mockAuthCode);
-
-        const updatedCode = { ...mockAuthCode, user_id: 'updated-user' };
-        await service.storeAuthCode(updatedCode);
-
-        const retrieved = await service.getAuthCode(mockAuthCode.code);
-        expect(retrieved?.user_id).toBe('updated-user');
-      });
-    });
-
-    describe('getAuthCode', () => {
-      it('should return undefined for non-existent code', async () => {
-        const result = await service.getAuthCode('non-existent-code');
-        expect(result).toBeUndefined();
-      });
-
-      it('should return the correct authorization code when it exists', async () => {
-        await service.storeAuthCode(mockAuthCode);
-        const result = await service.getAuthCode(mockAuthCode.code);
-        expect(result).toEqual(mockAuthCode);
-      });
-    });
-
-    describe('removeAuthCode', () => {
-      it('should remove an authorization code', async () => {
-        await service.storeAuthCode(mockAuthCode);
-        await service.removeAuthCode(mockAuthCode.code);
-
-        const retrieved = await service.getAuthCode(mockAuthCode.code);
-        expect(retrieved).toBeUndefined();
-      });
-
-      it('should not throw when removing non-existent code', async () => {
-        await expect(
-          service.removeAuthCode('non-existent-code'),
-        ).resolves.toBeUndefined();
-      });
-    });
-  });
-
-  describe('OAuth Session Management', () => {
-    const mockSession: OAuthSession = {
-      sessionId: 'session-123',
-      state: 'test-state',
-      clientId: 'client-123',
-      redirectUri: 'http://localhost:3000/callback',
-      codeChallenge: 'test-challenge',
-      codeChallengeMethod: 'S256',
-      oauthState: 'oauth-state-123',
-      resource: 'test-resource',
-      expiresAt: Date.now() + 3600000, // 1 hour from now
-    };
-
-    const expiredSession: OAuthSession = {
-      ...mockSession,
-      sessionId: 'expired-session',
-      expiresAt: Date.now() - 1000, // 1 second ago
-    };
-
-    describe('storeOAuthSession', () => {
-      it('should store an OAuth session', async () => {
-        const sessionId = 'session-123';
-        await service.storeOAuthSession(sessionId, mockSession);
-
-        const retrieved = await service.getOAuthSession(sessionId);
-        expect(retrieved).toEqual(mockSession);
-      });
-
-      it('should overwrite existing session with same ID', async () => {
-        const sessionId = 'session-123';
-        await service.storeOAuthSession(sessionId, mockSession);
-
-        const updatedSession = { ...mockSession, state: 'updated-state' };
-        await service.storeOAuthSession(sessionId, updatedSession);
-
-        const retrieved = await service.getOAuthSession(sessionId);
-        expect(retrieved?.state).toBe('updated-state');
-      });
-    });
-
-    describe('getOAuthSession', () => {
-      it('should return undefined for non-existent session', async () => {
-        const result = await service.getOAuthSession('non-existent-session');
-        expect(result).toBeUndefined();
-      });
-
-      it('should return the correct OAuth session when it exists', async () => {
-        const sessionId = 'session-123';
-        await service.storeOAuthSession(sessionId, mockSession);
-
-        const result = await service.getOAuthSession(sessionId);
-        expect(result).toEqual(mockSession);
-      });
-
-      it('should return undefined and auto-remove expired sessions', async () => {
-        const sessionId = 'expired-session';
-        await service.storeOAuthSession(sessionId, expiredSession);
-
-        const result = await service.getOAuthSession(sessionId);
-        expect(result).toBeUndefined();
-
-        // Verify it was actually removed
-        const result2 = await service.getOAuthSession(sessionId);
-        expect(result2).toBeUndefined();
-      });
-    });
-
-    describe('removeOAuthSession', () => {
-      it('should remove an OAuth session', async () => {
-        const sessionId = 'session-123';
-        await service.storeOAuthSession(sessionId, mockSession);
-        await service.removeOAuthSession(sessionId);
-
-        const retrieved = await service.getOAuthSession(sessionId);
-        expect(retrieved).toBeUndefined();
-      });
-
-      it('should not throw when removing non-existent session', async () => {
-        await expect(
-          service.removeOAuthSession('non-existent-session'),
-        ).resolves.toBeUndefined();
-      });
-    });
-  });
-});

package/src/authz/stores/memory-store.service.ts

@@ -1,141 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { createHash } from 'crypto';
-import {
-  OAuthSession,
-  OAuthUserProfile,
-} from '../providers/oauth-provider.interface';
-import type {
-  AuthorizationCode,
-  IOAuthStore,
-  OAuthClient,
-} from './oauth-store.interface';
-
-// In-memory storage (in production, use a database)
-@Injectable()
-export class MemoryStore implements IOAuthStore {
-  private clients = new Map<string, OAuthClient>();
-  private authCodes = new Map<string, AuthorizationCode>();
-  private oauthSessions = new Map<string, OAuthSession>();
-  private userProfiles = new Map<
-    string,
-    OAuthUserProfile & { profile_id: string; provider: string }
-  >(); // profile_id -> profile
-  private providerUserIndex = new Map<string, string>(); // key(provider:userId) -> profile_id
-
-  async storeClient(client: OAuthClient): Promise<OAuthClient> {
-    this.clients.set(client.client_id, client);
-    return client;
-  }
-
-  async getClient(client_id: string): Promise<OAuthClient | undefined> {
-    return this.clients.get(client_id);
-  }
-
-  async findClient(client_name: string): Promise<OAuthClient | undefined> {
-    for (const client of this.clients.values()) {
-      if (client.client_name === client_name) {
-        return client;
-      }
-    }
-    return undefined;
-  }
-
-  async storeAuthCode(code: AuthorizationCode): Promise<void> {
-    this.authCodes.set(code.code, code);
-  }
-
-  async getAuthCode(code: string): Promise<AuthorizationCode | undefined> {
-    return this.authCodes.get(code);
-  }
-
-  async removeAuthCode(code: string): Promise<void> {
-    this.authCodes.delete(code);
-  }
-
-  // New OAuth session methods for provider-agnostic flow
-  async storeOAuthSession(
-    sessionId: string,
-    session: OAuthSession,
-  ): Promise<void> {
-    this.oauthSessions.set(sessionId, session);
-  }
-
-  async getOAuthSession(sessionId: string): Promise<OAuthSession | undefined> {
-    const session = this.oauthSessions.get(sessionId);
-    if (session && session.expiresAt < Date.now()) {
-      this.oauthSessions.delete(sessionId);
-      return undefined;
-    }
-    return session;
-  }
-
-  async removeOAuthSession(sessionId: string): Promise<void> {
-    this.oauthSessions.delete(sessionId);
-  }
-
-  generateClientId(client: OAuthClient): string {
-    // Create deterministic client ID based on entire client object
-    const normalizedClient = this.normalizeClientObject(client);
-    const clientString = JSON.stringify(normalizedClient);
-    const hash = createHash('sha256').update(clientString).digest('hex');
-
-    // Use first 16 characters of hash with client name prefix for readability
-    const normalizedName = client.client_name
-      .toLowerCase()
-      .replace(/[^a-z0-9]/g, '');
-    return `${normalizedName}_${hash.substring(0, 16)}`;
-  }
-
-  private normalizeClientObject(client: OAuthClient): any {
-    // Create a normalized version of the client object for consistent hashing
-    const normalized: any = {};
-
-    // Sort object keys to ensure consistent ordering
-    const sortedKeys = Object.keys(client).sort();
-
-    for (const key of sortedKeys) {
-      const value = (client as any)[key];
-      if (Array.isArray(value)) {
-        // Sort arrays to ensure consistent ordering
-        normalized[key] = [...value].sort();
-      } else {
-        normalized[key] = value;
-      }
-    }
-
-    return normalized;
-  }
-
-  // User profile management
-  async upsertUserProfile(
-    profile: OAuthUserProfile,
-    provider: string,
-  ): Promise<string> {
-    const key = `${provider}:${profile.id}`;
-    let profileId = this.providerUserIndex.get(key);
-    if (!profileId) {
-      // create new
-      profileId = this.generateProfileId(provider, profile.id);
-      this.providerUserIndex.set(key, profileId);
-    }
-    this.userProfiles.set(profileId, {
-      profile_id: profileId,
-      provider,
-      ...profile,
-    });
-    return profileId;
-  }
-
-  async getUserProfileById(
-    profileId: string,
-  ): Promise<
-    (OAuthUserProfile & { profile_id: string; provider: string }) | undefined
-  > {
-    return this.userProfiles.get(profileId);
-  }
-
-  private generateProfileId(provider: string, providerUserId: string): string {
-    const input = `${provider}:${providerUserId}`;
-    return createHash('sha256').update(input).digest('hex').slice(0, 24);
-  }
-}