@goboost/scanner-typescript 1.2.1

package/src/dto-extractor.ts

@@ -0,0 +1,363 @@
+/**
+ * DTO extractor - finds DTO classes referenced by controller methods
+ * Extracts field names, TypeScript types, class-validator decorators, and nested DTO relationships
+ */
+import { Project, SourceFile, ClassDeclaration, PropertyDeclaration, Decorator, Node } from 'ts-morph';
+
+interface DTODefinition {
+  name: string;
+  sourceFile: string;
+  extends: string | null;
+  fields: DTOField[];
+  isShared: boolean;
+}
+
+interface DTOField {
+  name: string;
+  tsType: string;
+  isOptional: boolean;
+  isArray: boolean;
+  nestedDto: string | null;
+  validationRules: ValidationRule[];
+}
+
+interface ValidationRule {
+  decorator: string;
+  args: any[];
+  message: string | null;
+}
+
+const VALIDATION_DECORATORS = [
+  'IsString', 'IsNumber', 'IsEmail', 'IsInt', 'IsBoolean',
+  'Min', 'Max', 'MinLength', 'MaxLength', 'IsOptional',
+  'IsDate', 'IsArray', 'IsEnum', 'IsUUID', 'IsUrl',
+  'Matches', 'IsNotEmpty', 'IsDefined', 'IsPositive',
+  'IsNegative', 'IsDateString', 'IsISO8601', 'IsJSON',
+  'IsObject', 'IsNotEmptyObject', 'ValidateNested',
+];
+
+// Map class-validator decorators to Go validate tags
+const VALIDATOR_TO_GO_TAG: Record<string, string> = {
+  'IsString': '',
+  'IsNumber': '',
+  'IsEmail': 'email',
+  'IsInt': '',
+  'IsBoolean': '',
+  'Min': 'min',
+  'Max': 'max',
+  'MinLength': 'min',
+  'MaxLength': 'max',
+  'IsOptional': 'omitempty',
+  'IsDate': '',
+  'IsArray': '',
+  'IsEnum': 'oneof',
+  'IsUUID': 'uuid',
+  'IsUrl': 'url',
+  'Matches': 'regexp',
+  'IsNotEmpty': 'required',
+  'IsDefined': 'required',
+  'IsPositive': 'gt=0',
+  'IsDateString': '',
+  'IsJSON': '',
+};
+
+export function extractDTOs(project: Project, referencedDTOs: Set<string>): Record<string, DTODefinition> {
+  const dtos: Record<string, DTODefinition> = {};
+  const processedDTOs = new Set<string>();
+
+  // First pass: collect all DTO classes
+  const allDTOClasses: { classDecl: ClassDeclaration; sourceFile: SourceFile }[] = [];
+
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const classDecl of sourceFile.getClasses()) {
+      const name = classDecl.getName();
+      if (name && (isDTO(classDecl) || referencedDTOs.has(name))) {
+        allDTOClasses.push({ classDecl, sourceFile });
+      }
+    }
+  }
+
+  // Second pass: extract DTO definitions
+  for (const { classDecl, sourceFile } of allDTOClasses) {
+    const name = classDecl.getName();
+    if (name && !processedDTOs.has(name)) {
+      const dto = extractDTO(classDecl, sourceFile, referencedDTOs);
+      dtos[name] = dto;
+      processedDTOs.add(name);
+    }
+  }
+
+  // Mark shared DTOs (referenced by multiple controllers)
+  // This will be done by the caller who has knowledge of controller references
+
+  return dtos;
+}
+
+function isDTO(classDecl: ClassDeclaration): boolean {
+  // Check if class has validation decorators on properties
+  for (const prop of classDecl.getProperties()) {
+    const decorators = prop.getDecorators();
+    if (decorators.some(d => VALIDATION_DECORATORS.includes(d.getName()))) {
+      return true;
+    }
+  }
+
+  // Also check if class name ends with 'Dto' or 'DTO'
+  const name = classDecl.getName() || '';
+  return name.endsWith('Dto') || name.endsWith('DTO');
+}
+
+function extractDTO(
+  classDecl: ClassDeclaration,
+  sourceFile: SourceFile,
+  referencedDTOs: Set<string>
+): DTODefinition {
+  const name = classDecl.getName() || 'AnonymousDTO';
+  const fields = extractFields(classDecl, referencedDTOs);
+  const extendsClass = extractExtends(classDecl);
+
+  return {
+    name,
+    sourceFile: getRelativePath(sourceFile.getFilePath()),
+    extends: extendsClass,
+    fields,
+    isShared: false, // Will be determined by caller
+  };
+}
+
+function extractExtends(classDecl: ClassDeclaration): string | null {
+  const ext = classDecl.getExtends();
+  if (ext) {
+    const text = ext.getText();
+    // Extract just the class name, not the full path
+    return text.split('.').pop() || text;
+  }
+  return null;
+}
+
+function extractFields(classDecl: ClassDeclaration, referencedDTOs: Set<string>): DTOField[] {
+  const fields: DTOField[] = [];
+
+  for (const prop of classDecl.getProperties()) {
+    const typeText = prop.getType().getText();
+    const isArray = typeText.includes('[]') || typeText.includes('Array<');
+    const baseType = extractBaseType(typeText);
+
+    // Check for unmappable custom types
+    let unmappableType: string | null = null;
+    if (!isPrimitiveType(baseType) && !isBuiltInType(baseType) && !referencedDTOs.has(baseType)) {
+      // Check if it's a known framework type
+      if (!isKnownType(baseType)) {
+        unmappableType = baseType;
+      }
+    }
+
+    const field: DTOField = {
+      name: prop.getName(),
+      tsType: typeText,
+      isOptional: prop.hasQuestionToken() || hasOptionalDecorator(prop),
+      isArray,
+      nestedDto: null,
+      validationRules: extractValidation(prop),
+    };
+
+    // Check for nested DTO
+    if (!isPrimitiveType(baseType) && referencedDTOs.has(baseType)) {
+      field.nestedDto = baseType;
+    } else if (!isPrimitiveType(baseType) && !isBuiltInType(baseType)) {
+      // Potentially a nested DTO we haven't seen yet
+      field.nestedDto = baseType;
+    }
+
+    // Add validation rule for unmappable types (will be flagged during generation)
+    if (unmappableType) {
+      field.validationRules.push({
+        decorator: 'UnmappableType',
+        args: [unmappableType],
+        message: `Custom TypeScript type '${unmappableType}' cannot be automatically mapped to Go`,
+      });
+    }
+
+    fields.push(field);
+  }
+
+  return fields;
+}
+
+// Check if type is a known NestJS/framework type that can be mapped
+function isKnownType(type: string): boolean {
+  const knownTypes = [
+    // NestJS common types
+    'Request', 'Response', 'Next', 'ExecutionContext',
+    // Common third-party types
+    'ObjectId', 'Buffer',
+  ];
+  return knownTypes.includes(type);
+}
+
+function extractValidation(prop: PropertyDeclaration): ValidationRule[] {
+  const rules: ValidationRule[] = [];
+  const isOptional = prop.hasQuestionToken();
+
+  for (const decorator of prop.getDecorators()) {
+    const name = decorator.getName();
+    if (VALIDATION_DECORATORS.includes(name)) {
+      const rule: ValidationRule = {
+        decorator: name,
+        args: extractDecoratorArgs(decorator),
+        message: extractValidationMessage(decorator),
+      };
+      rules.push(rule);
+    }
+  }
+
+  // Add required validation if not optional and no IsOptional decorator
+  if (!isOptional && !rules.some(r => r.decorator === 'IsOptional')) {
+    // Don't add required - Go validator uses required by default
+    // unless omitempty is present
+  }
+
+  return rules;
+}
+
+function extractDecoratorArgs(decorator: Decorator): any[] {
+  const args: any[] = [];
+  const decoratorArgs = decorator.getArguments();
+
+  for (const arg of decoratorArgs) {
+    const argText = arg.getText();
+
+    // Try to parse as number
+    const num = parseFloat(argText);
+    if (!isNaN(num)) {
+      args.push(num);
+      continue;
+    }
+
+    // Try to parse as string literal
+    if (Node.isStringLiteral(arg)) {
+      args.push(argText.replace(/['"]/g, ''));
+      continue;
+    }
+
+    // Try to parse as object (simplified)
+    if (argText.startsWith('{')) {
+      try {
+        args.push(JSON.parse(argText));
+      } catch {
+        args.push(argText);
+      }
+      continue;
+    }
+
+    // Default: keep as string
+    args.push(argText);
+  }
+
+  return args;
+}
+
+function extractValidationMessage(decorator: Decorator): string | null {
+  const args = decorator.getArguments();
+  if (args.length > 0) {
+    const lastArg = args[args.length - 1];
+    const argText = lastArg.getText();
+    // Check if it's an options object with message
+    const messageMatch = argText.match(/message:\s*['"]([^'"]+)['"]/);
+    if (messageMatch) {
+      return messageMatch[1];
+    }
+  }
+  return null;
+}
+
+function hasOptionalDecorator(prop: PropertyDeclaration): boolean {
+  return prop.getDecorators().some(d => d.getName() === 'IsOptional');
+}
+
+function extractBaseType(typeText: string): string {
+  // Remove array notation
+  let base = typeText.replace(/\[\]$/, '').replace(/Array</, '').replace(/>$/, '');
+
+  // Remove generics
+  const genericMatch = base.match(/^(\w+)</);
+  if (genericMatch) {
+    base = genericMatch[1];
+  }
+
+  // Remove import paths
+  base = base.split('.').pop() || base;
+
+  return base.trim();
+}
+
+function isPrimitiveType(type: string): boolean {
+  const primitives = [
+    'string', 'number', 'boolean', 'Date', 'any', 'unknown',
+    'null', 'undefined', 'void', 'object', 'Buffer'
+  ];
+  return primitives.includes(type);
+}
+
+function isBuiltInType(type: string): boolean {
+  const builtIns = [
+    'Promise', 'Observable', 'Array', 'Map', 'Set', 'Record',
+    'Partial', 'Required', 'Readonly', 'Pick', 'Omit', 'Exclude', 'Extract'
+  ];
+  return builtIns.includes(type);
+}
+
+function getRelativePath(filePath: string): string {
+  const parts = filePath.split(/[\\/]/);
+  const srcIndex = parts.indexOf('src');
+  if (srcIndex !== -1) {
+    return parts.slice(srcIndex).join('/');
+  }
+  return filePath;
+}
+
+// Helper to collect all referenced DTOs from controllers
+export function collectReferencedDTOs(controllers: any[]): Set<string> {
+  const referenced = new Set<string>();
+
+  for (const controller of controllers) {
+    for (const route of controller.routes) {
+      if (route.requestBody?.$ref) {
+        referenced.add(route.requestBody.$ref);
+      }
+      if (route.responseBody?.$ref) {
+        referenced.add(route.responseBody.$ref);
+      }
+    }
+  }
+
+  return referenced;
+}
+
+// Mark DTOs that are shared across multiple controllers
+export function markSharedDTOs(dtos: Record<string, DTODefinition>, controllers: any[]): void {
+  const referenceCounts: Record<string, number> = {};
+
+  for (const controller of controllers) {
+    const controllerDTOs = new Set<string>();
+
+    for (const route of controller.routes) {
+      if (route.requestBody?.$ref) {
+        controllerDTOs.add(route.requestBody.$ref);
+      }
+      if (route.responseBody?.$ref) {
+        controllerDTOs.add(route.responseBody.$ref);
+      }
+    }
+
+    for (const dtoName of controllerDTOs) {
+      referenceCounts[dtoName] = (referenceCounts[dtoName] || 0) + 1;
+    }
+  }
+
+  for (const [name, count] of Object.entries(referenceCounts)) {
+    if (count > 1 && dtos[name]) {
+      dtos[name].isShared = true;
+    }
+  }
+}

package/src/guard-extractor.ts

@@ -0,0 +1,206 @@
+/**
+ * Guard extractor - finds @UseGuards references and classifies them
+ * Resolves guard class definitions, classifies as jwt/basic/custom
+ */
+import { Project, SourceFile, ClassDeclaration, Decorator, MethodDeclaration } from 'ts-morph';
+
+interface GuardSpec {
+  name: string;
+  sourceFile: string;
+  type: 'jwt' | 'basic' | 'custom';
+  canGenerate: boolean;
+  failureReason: string | null;
+}
+
+export function extractGuards(project: Project): Record<string, GuardSpec> {
+  const guards: Record<string, GuardSpec> = {};
+
+  // First pass: find all guard class definitions
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const classDecl of sourceFile.getClasses()) {
+      if (isGuardClass(classDecl)) {
+        const guard = extractGuard(classDecl, sourceFile);
+        if (guard && !guards[guard.name]) {
+          guards[guard.name] = guard;
+        }
+      }
+    }
+  }
+
+  // Second pass: find @UseGuards usages and ensure all guards are tracked
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const classDecl of sourceFile.getClasses()) {
+      collectGuardsFromClass(classDecl, guards, sourceFile);
+    }
+  }
+
+  return guards;
+}
+
+function isGuardClass(classDecl: ClassDeclaration): boolean {
+  // Check if class implements CanActivate
+  const implementsList = classDecl.getImplements();
+  for (const impl of implementsList) {
+    const text = impl.getText();
+    if (text.includes('CanActivate')) {
+      return true;
+    }
+  }
+
+  // Check extends AuthGuard
+  const ext = classDecl.getExtends();
+  if (ext) {
+    const extText = ext.getText();
+    if (extText.includes('AuthGuard')) {
+      return true;
+    }
+  }
+
+  // Check for @Injectable decorator with guard-like patterns
+  const hasInjectable = classDecl.getDecorators().some(d => d.getName() === 'Injectable');
+  const className = classDecl.getName() || '';
+  const isGuardByName = className.includes('Guard') || className.includes('AuthGuard');
+
+  return hasInjectable && isGuardByName;
+}
+
+function extractGuard(classDecl: ClassDeclaration, sourceFile: SourceFile): GuardSpec | null {
+  const name = classDecl.getName();
+  if (!name) return null;
+
+  const guardType = classifyGuard(classDecl);
+  const canGenerate = guardType !== 'custom';
+  const failureReason = canGenerate ? null : 'Custom guard logic cannot be automatically translated';
+
+  return {
+    name,
+    sourceFile: getRelativePath(sourceFile.getFilePath()),
+    type: guardType,
+    canGenerate,
+    failureReason,
+  };
+}
+
+function classifyGuard(classDecl: ClassDeclaration): 'jwt' | 'basic' | 'custom' {
+  const name = classDecl.getName() || '';
+  const ext = classDecl.getExtends();
+
+  // Check by name patterns
+  const nameLower = name.toLowerCase();
+  if (nameLower.includes('jwt') || nameLower.includes('jwtauth')) {
+    return 'jwt';
+  }
+  if (nameLower.includes('basic') || nameLower.includes('basicauth')) {
+    return 'basic';
+  }
+
+  // Check by extends
+  if (ext) {
+    const extText = ext.getText();
+    if (extText.includes('JwtAuthGuard') || extText.includes("AuthGuard('jwt')")) {
+      return 'jwt';
+    }
+    if (extText.includes("AuthGuard('basic')") || extText.includes('BasicAuthGuard')) {
+      return 'basic';
+    }
+  }
+
+  // Check source file content for patterns
+  const sourceFile = classDecl.getSourceFile();
+  const text = sourceFile.getFullText();
+
+  // JWT patterns
+  if (
+    text.includes('JwtService') ||
+    text.includes('jwt.verify') ||
+    text.includes('extractToken') ||
+    text.includes('JwtPayload') ||
+    text.includes('fromAuthHeaderAsBearerToken')
+  ) {
+    return 'jwt';
+  }
+
+  // Basic auth patterns
+  if (
+    text.includes('BasicAuth') ||
+    text.includes('btoa') ||
+    text.includes('atob') ||
+    text.includes('fromAuthHeaderAsBasicAuth')
+  ) {
+    return 'basic';
+  }
+
+  return 'custom';
+}
+
+function collectGuardsFromClass(
+  classDecl: ClassDeclaration,
+  guards: Record<string, GuardSpec>,
+  sourceFile: SourceFile
+): void {
+  // Check class-level @UseGuards
+  const classGuards = classDecl.getDecorators().find(d => d.getName() === 'UseGuards');
+  if (classGuards) {
+    parseGuardsFromDecorator(classGuards, guards, sourceFile);
+  }
+
+  // Check method-level @UseGuards
+  for (const method of classDecl.getMethods()) {
+    const methodGuards = method.getDecorators().find(d => d.getName() === 'UseGuards');
+    if (methodGuards) {
+      parseGuardsFromDecorator(methodGuards, guards, sourceFile);
+    }
+  }
+}
+
+function parseGuardsFromDecorator(
+  decorator: Decorator,
+  guards: Record<string, GuardSpec>,
+  sourceFile: SourceFile
+): void {
+  const args = decorator.getArguments();
+  for (const arg of args) {
+    let guardName = arg.getText().replace('()', '').trim();
+
+    // Handle new expressions or complex references
+    if (guardName.startsWith('new ')) {
+      guardName = guardName.replace('new ', '').replace(/\(.*\)/, '');
+    }
+
+    if (!guards[guardName]) {
+      // Try to classify the guard based on name
+      const guardType = classifyGuardByName(guardName);
+      const canGenerate = guardType !== 'custom';
+
+      guards[guardName] = {
+        name: guardName,
+        sourceFile: getRelativePath(sourceFile.getFilePath()),
+        type: guardType,
+        canGenerate,
+        failureReason: canGenerate ? null : 'Custom guard logic cannot be automatically translated',
+      };
+    }
+  }
+}
+
+function classifyGuardByName(name: string): 'jwt' | 'basic' | 'custom' {
+  const nameLower = name.toLowerCase();
+
+  if (nameLower.includes('jwt') || nameLower.includes('bearer')) {
+    return 'jwt';
+  }
+  if (nameLower.includes('basic')) {
+    return 'basic';
+  }
+
+  return 'custom';
+}
+
+function getRelativePath(filePath: string): string {
+  const parts = filePath.split(/[\\/]/);
+  const srcIndex = parts.indexOf('src');
+  if (srcIndex !== -1) {
+    return parts.slice(srcIndex).join('/');
+  }
+  return filePath;
+}