github-to-mcp-monorepo 1.0.0

package/packages/openapi-parser/tests/generators/fastapi.test.ts

@@ -0,0 +1,236 @@
+/**
+ * Tests for FastAPI analyzer
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { FastAPIAnalyzer } from '../../src/generators/fastapi-analyzer.js';
+import { FileContent } from '../../src/generators/types.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+describe('FastAPIAnalyzer', () => {
+  let analyzer: FastAPIAnalyzer;
+  let fixtureFiles: FileContent[];
+
+  beforeAll(async () => {
+    analyzer = new FastAPIAnalyzer();
+    
+    // Load fixture files
+    const fixturesPath = path.join(__dirname, '../../../tests/fixtures/fastapi-app');
+    
+    const mainContent = await fs.readFile(
+      path.join(fixturesPath, 'main.py'),
+      'utf-8'
+    );
+    const adminContent = await fs.readFile(
+      path.join(fixturesPath, 'routes/admin.py'),
+      'utf-8'
+    );
+
+    fixtureFiles = [
+      { path: 'main.py', content: mainContent, language: 'python' },
+      { path: 'routes/admin.py', content: adminContent, language: 'python' },
+    ];
+  });
+
+  describe('canAnalyze', () => {
+    it('should detect FastAPI code', () => {
+      const files: FileContent[] = [
+        { path: 'main.py', content: 'from fastapi import FastAPI\napp = FastAPI()' },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(true);
+    });
+
+    it('should detect Flask code', () => {
+      const files: FileContent[] = [
+        { path: 'app.py', content: 'from flask import Flask\napp = Flask(__name__)' },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(true);
+    });
+
+    it('should detect FastAPI decorators', () => {
+      const files: FileContent[] = [
+        { path: 'routes.py', content: '@app.get("/users")\nasync def get_users():' },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(true);
+    });
+
+    it('should not match non-Python API code', () => {
+      const files: FileContent[] = [
+        { path: 'utils.py', content: 'def helper():\n    return 42' },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(false);
+    });
+  });
+
+  describe('analyze', () => {
+    it('should extract routes from FastAPI files', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      expect(result.framework).toBe('fastapi');
+      expect(result.routes.length).toBeGreaterThan(0);
+      expect(result.filesAnalyzed.length).toBeGreaterThan(0);
+    });
+
+    it('should extract user routes', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const userRoutes = result.routes.filter(r => r.path.includes('/users'));
+      expect(userRoutes.length).toBeGreaterThan(0);
+      
+      // Check GET /users exists
+      const listUsersRoute = userRoutes.find(
+        r => r.method === 'get' && r.path === '/users'
+      );
+      expect(listUsersRoute).toBeDefined();
+      expect(listUsersRoute?.tags).toContain('Users');
+    });
+
+    it('should extract path parameters', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const getUserByIdRoute = result.routes.find(
+        r => r.method === 'get' && r.path === '/users/{user_id}'
+      );
+      
+      expect(getUserByIdRoute).toBeDefined();
+      expect(getUserByIdRoute?.pathParameters).toHaveLength(1);
+      expect(getUserByIdRoute?.pathParameters[0].name).toBe('user_id');
+    });
+
+    it('should extract Pydantic models as schemas', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      expect(Object.keys(result.schemas).length).toBeGreaterThan(0);
+      expect(result.schemas['UserCreate']).toBeDefined();
+      expect(result.schemas['UserResponse']).toBeDefined();
+    });
+
+    it('should extract query parameters', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const listUsersRoute = result.routes.find(
+        r => r.method === 'get' && r.path === '/users'
+      );
+      
+      expect(listUsersRoute?.queryParameters.length).toBeGreaterThan(0);
+      const skipParam = listUsersRoute?.queryParameters.find(p => p.name === 'skip');
+      expect(skipParam).toBeDefined();
+    });
+
+    it('should detect deprecated endpoints', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const deprecatedRoute = result.routes.find(
+        r => r.path.includes('/maintenance')
+      );
+      
+      expect(deprecatedRoute?.deprecated).toBe(true);
+    });
+
+    it('should extract admin routes', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const adminRoutes = result.routes.filter(r => r.path.includes('/admin'));
+      expect(adminRoutes.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('inline code analysis', () => {
+    it('should parse FastAPI decorator patterns', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'api.py',
+          content: `
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/items")
+async def list_items():
+    """List all items."""
+    return []
+
+@app.post("/items", status_code=201)
+async def create_item(item: dict):
+    """Create a new item."""
+    return item
+
+@app.delete("/items/{item_id}")
+async def delete_item(item_id: str):
+    """Delete an item."""
+    pass
+          `,
+          language: 'python',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.routes.length).toBe(3);
+      expect(result.routes.map(r => r.method)).toContain('get');
+      expect(result.routes.map(r => r.method)).toContain('post');
+      expect(result.routes.map(r => r.method)).toContain('delete');
+    });
+
+    it('should extract docstrings as descriptions', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'api.py',
+          content: `
+from fastapi import FastAPI
+app = FastAPI()
+
+@app.get("/test")
+async def test_endpoint():
+    """
+    This is a test endpoint.
+    
+    It returns a simple message.
+    """
+    return {"message": "test"}
+          `,
+          language: 'python',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.routes[0].summary).toBeDefined();
+    });
+  });
+
+  describe('Pydantic model parsing', () => {
+    it('should parse Pydantic models correctly', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'models.py',
+          content: `
+from pydantic import BaseModel
+from typing import Optional, List
+
+class Item(BaseModel):
+    name: str
+    price: float
+    tags: List[str] = []
+    description: Optional[str] = None
+
+@app.post("/items")
+async def create_item(item: Item):
+    return item
+          `,
+          language: 'python',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.schemas['Item']).toBeDefined();
+      const itemSchema = result.schemas['Item'];
+      expect(itemSchema.type).toBe('object');
+      expect(itemSchema.properties?.name).toBeDefined();
+      expect(itemSchema.properties?.price).toBeDefined();
+      expect(itemSchema.required).toContain('name');
+      expect(itemSchema.required).toContain('price');
+    });
+  });
+});

package/packages/openapi-parser/tests/generators/nextjs.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Tests for Next.js analyzer
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { NextJSAnalyzer } from '../../src/generators/nextjs-analyzer.js';
+import { FileContent } from '../../src/generators/types.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+describe('NextJSAnalyzer', () => {
+  let analyzer: NextJSAnalyzer;
+  let fixtureFiles: FileContent[];
+
+  beforeAll(async () => {
+    analyzer = new NextJSAnalyzer();
+    
+    // Load fixture files
+    const fixturesPath = path.join(__dirname, '../../../tests/fixtures/nextjs-app');
+    
+    const usersRouteContent = await fs.readFile(
+      path.join(fixturesPath, 'app/api/users/route.ts'),
+      'utf-8'
+    );
+    const userByIdRouteContent = await fs.readFile(
+      path.join(fixturesPath, 'app/api/users/[id]/route.ts'),
+      'utf-8'
+    );
+    const postsRouteContent = await fs.readFile(
+      path.join(fixturesPath, 'app/api/posts/route.ts'),
+      'utf-8'
+    );
+    const healthContent = await fs.readFile(
+      path.join(fixturesPath, 'pages/api/health.ts'),
+      'utf-8'
+    );
+
+    fixtureFiles = [
+      { path: 'app/api/users/route.ts', content: usersRouteContent, language: 'typescript' },
+      { path: 'app/api/users/[id]/route.ts', content: userByIdRouteContent, language: 'typescript' },
+      { path: 'app/api/posts/route.ts', content: postsRouteContent, language: 'typescript' },
+      { path: 'pages/api/health.ts', content: healthContent, language: 'typescript' },
+    ];
+  });
+
+  describe('canAnalyze', () => {
+    it('should detect Next.js App Router API routes', () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/api/users/route.ts',
+          content: "import { NextRequest, NextResponse } from 'next/server';",
+        },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(true);
+    });
+
+    it('should detect Next.js Pages Router API routes', () => {
+      const files: FileContent[] = [
+        {
+          path: 'pages/api/hello.ts',
+          content: 'export default function handler(req, res) {}',
+        },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(true);
+    });
+
+    it('should not match non-API files', () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/page.tsx',
+          content: 'export default function Page() { return <div>Hello</div>; }',
+        },
+      ];
+      expect(analyzer.canAnalyze(files)).toBe(false);
+    });
+  });
+
+  describe('analyze', () => {
+    it('should extract routes from Next.js files', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      expect(result.framework).toBe('nextjs');
+      expect(result.routes.length).toBeGreaterThan(0);
+      expect(result.filesAnalyzed.length).toBeGreaterThan(0);
+    });
+
+    it('should extract user routes from App Router', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const userRoutes = result.routes.filter(r => r.path.includes('/users'));
+      expect(userRoutes.length).toBeGreaterThan(0);
+      
+      // Check GET /api/users exists
+      const getUsersRoute = userRoutes.find(
+        r => r.method === 'get' && r.path === '/api/users'
+      );
+      expect(getUsersRoute).toBeDefined();
+    });
+
+    it('should extract dynamic route parameters', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const getUserByIdRoute = result.routes.find(
+        r => r.method === 'get' && r.path.includes('/users/{id}')
+      );
+      
+      expect(getUserByIdRoute).toBeDefined();
+      expect(getUserByIdRoute?.pathParameters).toHaveLength(1);
+      expect(getUserByIdRoute?.pathParameters[0].name).toBe('id');
+    });
+
+    it('should extract multiple HTTP methods from same route file', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const usersRoutes = result.routes.filter(r => 
+        r.path === '/api/users' && r.sourceFile.includes('app/api/users/route.ts')
+      );
+      
+      expect(usersRoutes.length).toBe(2); // GET and POST
+      expect(usersRoutes.map(r => r.method)).toContain('get');
+      expect(usersRoutes.map(r => r.method)).toContain('post');
+    });
+
+    it('should extract query parameters from searchParams usage', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const getUsersRoute = result.routes.find(
+        r => r.method === 'get' && r.path === '/api/users'
+      );
+      
+      expect(getUsersRoute?.queryParameters.length).toBeGreaterThan(0);
+    });
+
+    it('should detect header parameters', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const createPostRoute = result.routes.find(
+        r => r.method === 'post' && r.path.includes('/posts')
+      );
+      
+      expect(createPostRoute?.headerParameters.length).toBeGreaterThan(0);
+      expect(
+        createPostRoute?.headerParameters.some(p => p.name.toLowerCase() === 'authorization')
+      ).toBe(true);
+    });
+
+    it('should handle Pages Router routes', async () => {
+      const result = await analyzer.analyze(fixtureFiles);
+      
+      const healthRoute = result.routes.find(r => r.path.includes('/health'));
+      expect(healthRoute).toBeDefined();
+    });
+  });
+
+  describe('inline code analysis', () => {
+    it('should parse export async function patterns', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/api/items/route.ts',
+          content: `
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  return NextResponse.json({ items: [] });
+}
+
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  return NextResponse.json(body, { status: 201 });
+}
+          `,
+          language: 'typescript',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.routes.length).toBe(2);
+      expect(result.routes.map(r => r.method)).toContain('get');
+      expect(result.routes.map(r => r.method)).toContain('post');
+    });
+
+    it('should parse export const arrow function patterns', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/api/data/route.ts',
+          content: `
+import { NextResponse } from 'next/server';
+
+export const GET = async () => {
+  return NextResponse.json({ data: [] });
+};
+
+export const PUT = async (request) => {
+  return NextResponse.json({});
+};
+          `,
+          language: 'typescript',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.routes.length).toBe(2);
+      expect(result.routes.map(r => r.method)).toContain('get');
+      expect(result.routes.map(r => r.method)).toContain('put');
+    });
+  });
+
+  describe('path conversion', () => {
+    it('should convert [param] to {param}', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/api/users/[userId]/posts/[postId]/route.ts',
+          content: `
+export async function GET() {
+  return Response.json({});
+}
+          `,
+          language: 'typescript',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.routes[0].openApiPath).toBe('/api/users/{userId}/posts/{postId}');
+    });
+
+    it('should handle catch-all routes', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/api/[...slug]/route.ts',
+          content: `
+export async function GET() {
+  return Response.json({});
+}
+          `,
+          language: 'typescript',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      expect(result.routes[0].openApiPath).toBe('/api/{slug}');
+    });
+  });
+
+  describe('response inference', () => {
+    it('should extract status codes from NextResponse.json', async () => {
+      const files: FileContent[] = [
+        {
+          path: 'app/api/test/route.ts',
+          content: `
+import { NextResponse } from 'next/server';
+
+export async function POST() {
+  if (error) {
+    return NextResponse.json({ error: 'Bad request' }, { status: 400 });
+  }
+  return NextResponse.json({ id: '123' }, { status: 201 });
+}
+          `,
+          language: 'typescript',
+        },
+      ];
+
+      const result = await analyzer.analyze(files);
+      
+      const route = result.routes[0];
+      expect(route.responses.some(r => r.statusCode === 201)).toBe(true);
+      expect(route.responses.some(r => r.statusCode === 400)).toBe(true);
+    });
+  });
+});