@g1cloud/api-gen 1.0.0

package/src/parser/astAnalyzer.ts

@@ -0,0 +1,373 @@
+import { JavaClass, JavaAnnotation, JavaMethod } from '../types';
+
+export class ASTAnalyzer {
+  /**
+   * Check if a class is a REST controller
+   */
+  static isRestController(javaClass: JavaClass): boolean {
+    const annotations = javaClass.annotations;
+
+    // Check for @RestController
+    if (annotations.some((a) => a.name === 'RestController')) {
+      return true;
+    }
+
+    // Check for @Controller + @ResponseBody
+    const hasController = annotations.some((a) => a.name === 'Controller');
+    const hasResponseBody = annotations.some((a) => a.name === 'ResponseBody');
+
+    return hasController && hasResponseBody;
+  }
+
+  /**
+   * Extract base path from @RequestMapping annotation on class level
+   */
+  static getClassBasePath(javaClass: JavaClass): string {
+    const requestMapping = javaClass.annotations.find((a) => a.name === 'RequestMapping');
+
+    if (!requestMapping) {
+      return '';
+    }
+
+    const value = requestMapping.values['value'] || requestMapping.values['path'] || '';
+
+    if (Array.isArray(value)) {
+      return value[0] || '';
+    }
+
+    if (typeof value === 'boolean') {
+      return '';
+    }
+
+    return value;
+  }
+
+  /**
+   * Check if a method is an endpoint (has HTTP method annotation)
+   */
+  static isEndpointMethod(method: JavaMethod): boolean {
+    const httpAnnotations = [
+      'GetMapping',
+      'PostMapping',
+      'PutMapping',
+      'DeleteMapping',
+      'PatchMapping',
+      'RequestMapping',
+    ];
+
+    return method.annotations.some((a) => httpAnnotations.includes(a.name));
+  }
+
+  /**
+   * Get HTTP method from annotation
+   */
+  static getHttpMethod(method: JavaMethod): string | null {
+    const mappingAnnotations: Record<string, string> = {
+      GetMapping: 'get',
+      PostMapping: 'post',
+      PutMapping: 'put',
+      DeleteMapping: 'delete',
+      PatchMapping: 'patch',
+    };
+
+    for (const annotation of method.annotations) {
+      if (annotation.name in mappingAnnotations) {
+        return mappingAnnotations[annotation.name];
+      }
+
+      if (annotation.name === 'RequestMapping') {
+        const methodValue = annotation.values['method'];
+        if (methodValue && typeof methodValue !== 'boolean') {
+          const methodStr = Array.isArray(methodValue) ? methodValue[0] : methodValue;
+          const normalizedMethod = methodStr.toLowerCase().replace('requestmethod.', '');
+          return normalizedMethod;
+        }
+        // Default to GET if no method specified
+        return 'get';
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get endpoint path from method annotation
+   */
+  static getMethodPath(method: JavaMethod): string {
+    const mappingAnnotations = [
+      'GetMapping',
+      'PostMapping',
+      'PutMapping',
+      'DeleteMapping',
+      'PatchMapping',
+      'RequestMapping',
+    ];
+
+    for (const annotation of method.annotations) {
+      if (mappingAnnotations.includes(annotation.name)) {
+        const value = annotation.values['value'] || annotation.values['path'] || '';
+
+        if (Array.isArray(value)) {
+          return value[0] || '';
+        }
+
+        if (typeof value === 'boolean') {
+          return '';
+        }
+
+        return value;
+      }
+    }
+
+    return '';
+  }
+
+  /**
+   * Check if an annotation indicates a request parameter
+   */
+  static isParameterAnnotation(annotation: JavaAnnotation): boolean {
+    const paramAnnotations = ['RequestParam', 'PathVariable', 'RequestHeader', 'RequestBody'];
+    return paramAnnotations.includes(annotation.name);
+  }
+
+  /**
+   * Get parameter type (query, path, header, body)
+   */
+  static getParameterType(annotations: JavaAnnotation[]): 'query' | 'path' | 'header' | 'body' | null {
+    for (const annotation of annotations) {
+      switch (annotation.name) {
+        case 'RequestParam':
+          return 'query';
+        case 'PathVariable':
+          return 'path';
+        case 'RequestHeader':
+          return 'header';
+        case 'RequestBody':
+          return 'body';
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if a type is a SearchParam
+   */
+  static isSearchParam(type: string): boolean {
+    return type === 'SearchParam' || type.endsWith('.SearchParam');
+  }
+
+  /**
+   * Check if a type is a PaginatedList
+   */
+  static isPaginatedList(type: string): boolean {
+    return type === 'PaginatedList' || type.startsWith('PaginatedList') || type.endsWith('.PaginatedList');
+  }
+
+  /**
+   * Extract generic type from a parameterized type
+   */
+  static extractGenericType(genericType: string | undefined): string | undefined {
+    if (!genericType) return undefined;
+
+    // Handle nested generics like PaginatedList<UserDTO>
+    const match = genericType.match(/^([^<]+)(?:<(.+)>)?$/);
+    if (match) {
+      return match[1].trim();
+    }
+
+    return genericType;
+  }
+
+  /**
+   * Check if method has security annotations
+   */
+  static hasSecurityAnnotation(method: JavaMethod): boolean {
+    const securityAnnotations = ['PreAuthorize', 'PostAuthorize', 'Secured', 'RolesAllowed'];
+    return method.annotations.some((a) => securityAnnotations.includes(a.name));
+  }
+
+  /**
+   * Get security annotation from method
+   */
+  static getSecurityAnnotations(method: JavaMethod): JavaAnnotation[] {
+    const securityAnnotations = ['PreAuthorize', 'PostAuthorize', 'Secured', 'RolesAllowed'];
+    return method.annotations.filter((a) => securityAnnotations.includes(a.name));
+  }
+
+  /**
+   * Combine base path with method path
+   */
+  static combinePaths(basePath: string, methodPath: string): string {
+    // Normalize paths
+    const normalizedBase = basePath.replace(/\/+$/, '');
+    const normalizedMethod = methodPath.replace(/^\/+/, '');
+
+    if (!normalizedBase && !normalizedMethod) {
+      return '/';
+    }
+
+    if (!normalizedBase) {
+      return '/' + normalizedMethod;
+    }
+
+    if (!normalizedMethod) {
+      return normalizedBase.startsWith('/') ? normalizedBase : '/' + normalizedBase;
+    }
+
+    const combined = `${normalizedBase}/${normalizedMethod}`;
+    return combined.startsWith('/') ? combined : '/' + combined;
+  }
+
+  /**
+   * Convert Java type to OpenAPI type
+   */
+  static javaTypeToOpenAPI(javaType: string): { type: string; format?: string } {
+    const typeMap: Record<string, { type: string; format?: string }> = {
+      // Primitives
+      int: { type: 'integer', format: 'int32' },
+      long: { type: 'integer', format: 'int64' },
+      short: { type: 'integer' },
+      byte: { type: 'integer' },
+      float: { type: 'number', format: 'float' },
+      double: { type: 'number', format: 'double' },
+      boolean: { type: 'boolean' },
+      char: { type: 'string' },
+
+      // Wrapper types
+      Integer: { type: 'integer', format: 'int32' },
+      Long: { type: 'integer', format: 'int64' },
+      Short: { type: 'integer' },
+      Byte: { type: 'integer' },
+      Float: { type: 'number', format: 'float' },
+      Double: { type: 'number', format: 'double' },
+      Boolean: { type: 'boolean' },
+      Character: { type: 'string' },
+
+      // String types
+      String: { type: 'string' },
+
+      // Date/Time types
+      Date: { type: 'string', format: 'date-time' },
+      LocalDate: { type: 'string', format: 'date' },
+      LocalDateTime: { type: 'string', format: 'date-time' },
+      LocalTime: { type: 'string', format: 'time' },
+      Instant: { type: 'string', format: 'date-time' },
+      ZonedDateTime: { type: 'string', format: 'date-time' },
+      OffsetDateTime: { type: 'string', format: 'date-time' },
+
+      // UUID
+      UUID: { type: 'string', format: 'uuid' },
+
+      // BigDecimal/BigInteger
+      BigDecimal: { type: 'number' },
+      BigInteger: { type: 'integer' },
+
+      // Currency
+      Currency: { type: 'string' },
+
+      // Void
+      void: { type: 'object' },
+      Void: { type: 'object' },
+    };
+
+    // Check if it's an array type
+    if (javaType.endsWith('[]')) {
+      return { type: 'array' };
+    }
+
+    // Extract simple type name from fully qualified name
+    const simpleName = javaType.split('.').pop() || javaType;
+
+    return typeMap[simpleName] || { type: 'object' };
+  }
+
+  /**
+   * Check if a Java type is a primitive or wrapper type
+   */
+  static isPrimitiveOrWrapper(javaType: string): boolean {
+    const primitiveTypes = [
+      'int',
+      'long',
+      'short',
+      'byte',
+      'float',
+      'double',
+      'boolean',
+      'char',
+      'Integer',
+      'Long',
+      'Short',
+      'Byte',
+      'Float',
+      'Double',
+      'Boolean',
+      'Character',
+      'String',
+      'Date',
+      'LocalDate',
+      'LocalDateTime',
+      'LocalTime',
+      'Instant',
+      'ZonedDateTime',
+      'OffsetDateTime',
+      'UUID',
+      'BigDecimal',
+      'BigInteger',
+      'Currency',
+      'void',
+      'Void',
+    ];
+
+    const simpleName = javaType.split('.').pop() || javaType;
+    return primitiveTypes.includes(simpleName);
+  }
+
+  /**
+   * Check if a type is a collection type
+   */
+  static isCollectionType(javaType: string): boolean {
+    const collectionTypes = ['List', 'Set', 'Collection', 'ArrayList', 'HashSet', 'LinkedList', 'TreeSet'];
+    const simpleName = javaType.split('.').pop() || javaType;
+    return collectionTypes.includes(simpleName) || javaType.endsWith('[]');
+  }
+
+  /**
+   * Check if a type is a Map type
+   */
+  static isMapType(javaType: string): boolean {
+    const mapTypes = ['Map', 'HashMap', 'TreeMap', 'LinkedHashMap', 'ConcurrentHashMap'];
+    const simpleName = javaType.split('.').pop() || javaType;
+    return mapTypes.includes(simpleName);
+  }
+
+  /**
+   * Check if the return type is ResponseEntity
+   */
+  static isResponseEntity(returnType: string): boolean {
+    return returnType === 'ResponseEntity' || returnType.endsWith('.ResponseEntity');
+  }
+
+  /**
+   * Generate operation ID from method name
+   */
+  static generateOperationId(className: string, methodName: string): string {
+    // Remove Controller suffix from class name
+    const simplifiedClassName = className.replace(/Controller$/, '');
+
+    // Convert to camelCase
+    const operationId = simplifiedClassName.charAt(0).toLowerCase() + simplifiedClassName.slice(1) + '_' + methodName;
+
+    return operationId;
+  }
+
+  /**
+   * Generate summary from method name
+   */
+  static generateSummary(methodName: string): string {
+    // Convert camelCase to words
+    const words = methodName.replace(/([A-Z])/g, ' $1').trim();
+
+    // Capitalize first letter
+    return words.charAt(0).toUpperCase() + words.slice(1);
+  }
+}