@goboost/scanner-typescript 1.2.1

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@goboost/scanner-typescript",
+  "version": "1.2.1",
+  "description": "TypeScript AST scanner for source-framework-to-Go migration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "scan": "node dist/index.js"
+  },
+  "dependencies": {
+    "@prisma/internals": "^6.0.0",
+    "ts-morph": "^21.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/controller-extractor.ts

@@ -0,0 +1,364 @@
+/**
+ * Controller extractor - finds @HybridRoute + @Controller decorated classes
+ * Extracts basePath, method decorators, handler names, path/query params, and guard decorators
+ */
+import { Project, SourceFile, ClassDeclaration, Decorator, MethodDeclaration, ParameterDeclaration, Node } from 'ts-morph';
+
+interface ControllerSpec {
+  name: string;
+  basePath: string;
+  sourceFile: string;
+  guards: string[];
+  dependencies: string[];
+  routes: RouteMapping[];
+  unsupportedFeatures: string[];
+  hasHybridRoute: boolean;
+}
+
+interface RouteMapping {
+  id: string;
+  httpMethod: string;
+  path: string;
+  handlerName: string;
+  pathParams: ParamDef[];
+  queryParams: ParamDef[];
+  requestBody: DtoRef | null;
+  responseBody: DtoRef | null;
+  statusCode: number;
+  guards: string[];
+  unsupportedFeatures: string[];
+  canGenerate: boolean;
+}
+
+interface DtoRef {
+  $ref: string;
+}
+
+interface ParamDef {
+  name: string;
+  type: string;
+  isRequired: boolean;
+}
+
+const HTTP_METHOD_DECORATORS = ['Get', 'Post', 'Put', 'Delete', 'Patch'];
+
+// Status code mapping based on HTTP method
+const DEFAULT_STATUS_CODES: Record<string, number> = {
+  'GET': 200,
+  'POST': 201,
+  'PUT': 200,
+  'PATCH': 200,
+  'DELETE': 200,
+};
+
+export function extractControllers(project: Project): ControllerSpec[] {
+  const controllers: ControllerSpec[] = [];
+
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const classDecl of sourceFile.getClasses()) {
+      if (hasHybridRouteDecorator(classDecl)) {
+        const controller = extractController(classDecl, sourceFile);
+        controllers.push(controller);
+      }
+    }
+  }
+
+  // Sort controllers alphabetically by name for determinism
+  controllers.sort((a, b) => a.name.localeCompare(b.name));
+
+  return controllers;
+}
+
+function hasHybridRouteDecorator(classDecl: ClassDeclaration): boolean {
+  const decorators = classDecl.getDecorators();
+  return decorators.some(d => d.getName() === 'HybridRoute');
+}
+
+function extractController(classDecl: ClassDeclaration, sourceFile: SourceFile): ControllerSpec {
+  const name = classDecl.getName() || 'AnonymousController';
+  const basePath = extractBasePath(classDecl);
+  const classGuards = extractClassGuards(classDecl);
+  const dependencies = extractDependencies(classDecl);
+  const { routes, unsupportedFeatures } = extractRoutes(classDecl, name, classGuards);
+
+  return {
+    name,
+    basePath,
+    sourceFile: getRelativePath(sourceFile.getFilePath()),
+    guards: classGuards,
+    dependencies,
+    routes,
+    unsupportedFeatures,
+    hasHybridRoute: true,
+  };
+}
+
+function extractBasePath(classDecl: ClassDeclaration): string {
+  const controllerDecorator = classDecl.getDecorators().find(d => d.getName() === 'Controller');
+  if (!controllerDecorator) return '';
+
+  const args = controllerDecorator.getArguments();
+  if (args.length > 0) {
+    const arg = args[0];
+    if (Node.isStringLiteral(arg)) {
+      return arg.getText().replace(/['"]/g, '');
+    }
+  }
+  return '';
+}
+
+function extractClassGuards(classDecl: ClassDeclaration): string[] {
+  const guards: string[] = [];
+  const useGuardsDecorator = classDecl.getDecorators().find(d => d.getName() === 'UseGuards');
+  if (useGuardsDecorator) {
+    const args = useGuardsDecorator.getArguments();
+    for (const arg of args) {
+      const guardName = arg.getText().replace('()', '').trim();
+      guards.push(guardName);
+    }
+  }
+  return guards;
+}
+
+function extractDependencies(classDecl: ClassDeclaration): string[] {
+  const dependencies: string[] = [];
+  for (const prop of classDecl.getProperties()) {
+    const type = prop.getType().getText();
+    // Extract service names from injected properties
+    if (type.includes('Service')) {
+      dependencies.push(type);
+    }
+  }
+  return dependencies;
+}
+
+function extractRoutes(
+  classDecl: ClassDeclaration,
+  controllerName: string,
+  classGuards: string[]
+): { routes: RouteMapping[]; unsupportedFeatures: string[] } {
+  const routes: RouteMapping[] = [];
+  const controllerUnsupported: string[] = [];
+
+  for (const method of classDecl.getMethods()) {
+    for (const decoratorName of HTTP_METHOD_DECORATORS) {
+      const httpDecorator = method.getDecorators().find(d => d.getName() === decoratorName);
+      if (httpDecorator) {
+        const routePath = extractDecoratorPath(httpDecorator);
+        const methodGuards = extractMethodGuards(method);
+        const allGuards = [...new Set([...classGuards, ...methodGuards])];
+
+        const route: RouteMapping = {
+          id: `${controllerName}:${decoratorName.toUpperCase()}:${routePath || '/'}`,
+          httpMethod: decoratorName.toUpperCase(),
+          path: routePath || '/',
+          handlerName: method.getName(),
+          pathParams: extractPathParams(method),
+          queryParams: extractQueryParams(method),
+          requestBody: extractRequestBody(method),
+          responseBody: extractResponseBody(method),
+          statusCode: extractStatusCode(method, decoratorName.toUpperCase()),
+          guards: methodGuards, // Only route-level guards
+          unsupportedFeatures: [],
+          canGenerate: true,
+        };
+
+        routes.push(route);
+        break;
+      }
+    }
+  }
+
+  // Sort routes by method then path for determinism
+  routes.sort((a, b) => {
+    const methodCompare = a.httpMethod.localeCompare(b.httpMethod);
+    if (methodCompare !== 0) return methodCompare;
+    return a.path.localeCompare(b.path);
+  });
+
+  // Edge case: Empty controller (no routes)
+  // Add warning flag if controller has @HybridRoute but no HTTP method decorators
+  if (routes.length === 0) {
+    controllerUnsupported.push('empty-controller');
+  }
+
+  return { routes, unsupportedFeatures: controllerUnsupported };
+}
+
+function extractDecoratorPath(decorator: Decorator): string {
+  const args = decorator.getArguments();
+  if (args.length > 0) {
+    const arg = args[0];
+    if (Node.isStringLiteral(arg)) {
+      return arg.getText().replace(/['"]/g, '');
+    }
+  }
+  return '';
+}
+
+function extractPathParams(method: MethodDeclaration): ParamDef[] {
+  const params: ParamDef[] = [];
+  for (const param of method.getParameters()) {
+    const paramDecorator = param.getDecorators().find(d => d.getName() === 'Param');
+    if (paramDecorator) {
+      const args = paramDecorator.getArguments();
+      const paramName = args.length > 0 && Node.isStringLiteral(args[0])
+        ? args[0].getText().replace(/['"]/g, '')
+        : param.getName();
+
+      params.push({
+        name: paramName,
+        type: mapTypeToGo(param.getType().getText()),
+        isRequired: true,
+      });
+    }
+  }
+  return params;
+}
+
+function extractQueryParams(method: MethodDeclaration): ParamDef[] {
+  const params: ParamDef[] = [];
+  for (const param of method.getParameters()) {
+    const queryDecorator = param.getDecorators().find(d => d.getName() === 'Query');
+    if (queryDecorator) {
+      const args = queryDecorator.getArguments();
+      const paramName = args.length > 0 && Node.isStringLiteral(args[0])
+        ? args[0].getText().replace(/['"]/g, '')
+        : param.getName();
+
+      params.push({
+        name: paramName,
+        type: mapTypeToGo(param.getType().getText()),
+        isRequired: !param.hasQuestionToken(),
+      });
+    }
+  }
+  return params;
+}
+
+function extractRequestBody(method: MethodDeclaration): DtoRef | null {
+  for (const param of method.getParameters()) {
+    const bodyDecorator = param.getDecorators().find(d => d.getName() === 'Body');
+    if (bodyDecorator) {
+      const type = param.getType();
+      const typeName = extractTypeName(type.getText());
+      if (typeName) {
+        return { $ref: typeName };
+      }
+    }
+  }
+  return null;
+}
+
+function extractResponseBody(method: MethodDeclaration): DtoRef | null {
+  const returnType = method.getReturnType();
+  const returnText = returnType.getText();
+
+  // Extract from Promise<T> or Observable<T>
+  const promiseMatch = returnText.match(/Promise<(.+)>/);
+  const observableMatch = returnText.match(/Observable<(.+)>/);
+
+  let typeName = returnText;
+  if (promiseMatch) {
+    typeName = promiseMatch[1];
+  } else if (observableMatch) {
+    typeName = observableMatch[1];
+  }
+
+  // Skip void and primitive types
+  if (typeName === 'void' || isPrimitiveType(typeName)) {
+    return null;
+  }
+
+  const cleanName = extractTypeName(typeName);
+  if (cleanName) {
+    return { $ref: cleanName };
+  }
+
+  return null;
+}
+
+function extractStatusCode(method: MethodDeclaration, httpMethod: string): number {
+  const httpCodeDecorator = method.getDecorators().find(d => d.getName() === 'HttpCode');
+  if (httpCodeDecorator) {
+    const args = httpCodeDecorator.getArguments();
+    if (args.length > 0) {
+      const code = parseInt(args[0].getText(), 10);
+      if (!isNaN(code)) {
+        return code;
+      }
+    }
+  }
+  return DEFAULT_STATUS_CODES[httpMethod] || 200;
+}
+
+function extractMethodGuards(method: MethodDeclaration): string[] {
+  const guards: string[] = [];
+  const useGuardsDecorator = method.getDecorators().find(d => d.getName() === 'UseGuards');
+  if (useGuardsDecorator) {
+    const args = useGuardsDecorator.getArguments();
+    for (const arg of args) {
+      const guardName = arg.getText().replace('()', '').trim();
+      guards.push(guardName);
+    }
+  }
+  return guards;
+}
+
+function extractTypeName(typeText: string): string | null {
+  // Handle arrays
+  if (typeText.endsWith('[]')) {
+    return extractTypeName(typeText.slice(0, -2));
+  }
+
+  // Handle generics like Array<T>
+  const arrayMatch = typeText.match(/Array<(.+)>/);
+  if (arrayMatch) {
+    return extractTypeName(arrayMatch[1]);
+  }
+
+  // Skip primitives
+  if (isPrimitiveType(typeText)) {
+    return null;
+  }
+
+  // Clean up type name (remove imports path, etc.)
+  const cleanName = typeText.split('.').pop()?.split('<')[0].trim();
+  return cleanName || null;
+}
+
+function isPrimitiveType(type: string): boolean {
+  const primitives = [
+    'string', 'number', 'boolean', 'void', 'any', 'unknown',
+    'null', 'undefined', 'object', 'Date', 'Buffer',
+    'Promise<void>', 'Observable<void>'
+  ];
+  return primitives.some(p => type === p || type.includes(p + '<') || type === p + '[]');
+}
+
+function mapTypeToGo(tsType: string): string {
+  const typeMap: Record<string, string> = {
+    'string': 'string',
+    'number': 'float64',
+    'boolean': 'bool',
+    'Date': 'time.Time',
+  };
+
+  for (const [ts, go] of Object.entries(typeMap)) {
+    if (tsType.includes(ts)) {
+      return go;
+    }
+  }
+
+  return 'any';
+}
+
+function getRelativePath(filePath: string): string {
+  // Convert absolute path to relative from project root
+  const parts = filePath.split(/[\\/]/);
+  const srcIndex = parts.indexOf('src');
+  if (srcIndex !== -1) {
+    return parts.slice(srcIndex).join('/');
+  }
+  return filePath;
+}