@g1cloud/api-gen 1.0.0

package/src/analyzer/schemaGenerator.ts

@@ -0,0 +1,412 @@
+import {
+  JavaClass,
+  JavaField,
+  JavaAnnotation,
+  SchemaInfo,
+  ProcessingContext,
+} from '../types';
+import { ASTAnalyzer } from '../parser/astAnalyzer';
+
+/**
+ * Generate OpenAPI schemas for all referenced types
+ */
+export function generateSchemas(context: ProcessingContext): Map<string, SchemaInfo> {
+  const schemas = new Map<string, SchemaInfo>(context.dtoSchemas);
+
+  // Add standard schemas for SearchParam, Filter, Sort
+  addStandardSchemas(schemas);
+
+  // Process all referenced types
+  const processedTypes = new Set<string>();
+  const typesToProcess = [...context.referencedTypes];
+
+  while (typesToProcess.length > 0) {
+    const typeName = typesToProcess.pop()!;
+
+    if (processedTypes.has(typeName)) {
+      continue;
+    }
+
+    processedTypes.add(typeName);
+
+    // Skip primitive types
+    if (ASTAnalyzer.isPrimitiveOrWrapper(typeName)) {
+      continue;
+    }
+
+    // Skip if already in schemas
+    if (schemas.has(typeName)) {
+      continue;
+    }
+
+    // Find the Java class for this type
+    const javaClass = context.javaClasses.get(typeName);
+
+    if (javaClass) {
+      // Handle enum types
+      if (javaClass.isEnum && javaClass.enumValues) {
+        schemas.set(typeName, {
+          type: 'string',
+          enum: javaClass.enumValues,
+          description: javaClass.javadoc,
+        });
+      } else {
+        const { schema, nestedTypes } = generateSchemaForClass(javaClass, context);
+        schemas.set(typeName, schema);
+
+        // Add nested types to process
+        for (const nestedType of nestedTypes) {
+          if (!processedTypes.has(nestedType)) {
+            typesToProcess.push(nestedType);
+          }
+        }
+      }
+    } else {
+      // Type not found, create a generic object schema
+      schemas.set(typeName, {
+        type: 'object',
+        description: `Schema for ${typeName}`,
+      });
+    }
+  }
+
+  return schemas;
+}
+
+/**
+ * Add standard schemas for SearchParam, Filter, Sort
+ */
+function addStandardSchemas(schemas: Map<string, SchemaInfo>): void {
+  // Filter schema
+  if (!schemas.has('Filter')) {
+    schemas.set('Filter', {
+      type: 'object',
+      description: 'Filter conditions',
+    });
+  }
+
+  // Sort schema
+  if (!schemas.has('Sort')) {
+    schemas.set('Sort', {
+      type: 'object',
+      description: 'Sort conditions',
+    });
+  }
+
+  // SearchParam schema (for reference)
+  if (!schemas.has('SearchParam')) {
+    schemas.set('SearchParam', {
+      type: 'object',
+      description: 'Search parameters for pagination and filtering',
+      properties: {
+        offset: { type: 'integer', description: 'Pagination offset' },
+        limit: { type: 'integer', description: 'Pagination limit' },
+        filter: { $ref: '#/components/schemas/Filter' },
+        sort: { $ref: '#/components/schemas/Sort' },
+      },
+    });
+  }
+
+  // MultiLangString schema - Map<String, String>
+  if (!schemas.has('MultiLangString')) {
+    schemas.set('MultiLangString', {
+      type: 'object',
+      description: 'Multi-language string (Map<String, String>)',
+      additionalProperties: { type: 'string' },
+    });
+  }
+
+  // StoredFile schema
+  if (!schemas.has('StoredFile')) {
+    schemas.set('StoredFile', {
+      type: 'object',
+      description: 'Stored file information',
+      properties: {
+        fileUrl: { type: 'string', description: 'File URL' },
+        mediaType: { type: 'MediaType', enum: ['Image', 'Vide', 'Youtube', 'Unknown'], description: 'Media type' },
+        thumbnailUrl: { type: 'string', description: 'Thumbnail URL' },
+        fileName: { type: 'string', description: 'Original file name' },
+        altText: { type: 'string', description: 'Alternative text for the file' },
+        width: { type: 'integer', description: 'Width of the media' },
+        height: { type: 'integer', description: 'Height of the media' },
+      },
+    });
+  }
+
+  // MultiLangStoredFile schema - Map<String, StoredFile>
+  if (!schemas.has('MultiLangStoredFile')) {
+    schemas.set('MultiLangStoredFile', {
+      type: 'object',
+      description: 'Multi-language stored file (Map<String, StoredFile>)',
+      additionalProperties: { $ref: '#/components/schemas/StoredFile' },
+    });
+  }
+}
+
+/**
+ * Generate schema for a Java class, including inherited fields from superclass
+ */
+function generateSchemaForClass(
+  javaClass: JavaClass,
+  context: ProcessingContext
+): { schema: SchemaInfo; nestedTypes: string[] } {
+  const properties: Record<string, SchemaInfo> = {};
+  const required: string[] = [];
+  const nestedTypes: string[] = [];
+
+  // Collect all fields including inherited ones
+  const allFields = collectAllFields(javaClass, context);
+
+  for (const field of allFields) {
+    const { propertySchema, isRequired, referencedType } = generatePropertySchema(field);
+
+    properties[field.name] = propertySchema;
+
+    if (isRequired) {
+      required.push(field.name);
+    }
+
+    if (referencedType) {
+      nestedTypes.push(referencedType);
+    }
+  }
+
+  const schema: SchemaInfo = {
+    type: 'object',
+    properties,
+  };
+
+  if (required.length > 0) {
+    schema.required = required;
+  }
+
+  return { schema, nestedTypes };
+}
+
+/**
+ * Collect all fields from a class and its superclasses
+ */
+function collectAllFields(javaClass: JavaClass, context: ProcessingContext): JavaField[] {
+  const fields: JavaField[] = [];
+  const visitedClasses = new Set<string>();
+
+  let currentClass: JavaClass | undefined = javaClass;
+
+  while (currentClass && !visitedClasses.has(currentClass.name)) {
+    visitedClasses.add(currentClass.name);
+
+    // Add fields from current class (prepend to maintain inheritance order: parent fields first)
+    fields.unshift(...currentClass.fields);
+
+    // Move to superclass
+    if (currentClass.superClass) {
+      currentClass = context.javaClasses.get(currentClass.superClass);
+    } else {
+      break;
+    }
+  }
+
+  return fields;
+}
+
+/**
+ * Generate schema for a field
+ */
+function generatePropertySchema(field: JavaField): {
+  propertySchema: SchemaInfo;
+  isRequired: boolean;
+  referencedType?: string;
+} {
+  let isRequired = false;
+  let referencedType: string | undefined;
+
+  // Check for validation annotations
+  const constraints = extractValidationConstraints(field.annotations);
+  isRequired = constraints.required;
+
+  // Generate base schema based on type
+  let propertySchema: SchemaInfo;
+
+  if (ASTAnalyzer.isPrimitiveOrWrapper(field.type)) {
+    propertySchema = ASTAnalyzer.javaTypeToOpenAPI(field.type);
+  } else if (field.type.endsWith('[]')) {
+    const elementType = field.type.slice(0, -2);
+    if (ASTAnalyzer.isPrimitiveOrWrapper(elementType)) {
+      propertySchema = {
+        type: 'array',
+        items: ASTAnalyzer.javaTypeToOpenAPI(elementType),
+      };
+    } else {
+      referencedType = elementType;
+      propertySchema = {
+        type: 'array',
+        items: { $ref: `#/components/schemas/${elementType}` },
+      };
+    }
+  } else if (ASTAnalyzer.isCollectionType(field.type)) {
+    const itemType = field.genericType ? extractMainType(field.genericType) : 'Object';
+    if (ASTAnalyzer.isPrimitiveOrWrapper(itemType)) {
+      propertySchema = {
+        type: 'array',
+        items: ASTAnalyzer.javaTypeToOpenAPI(itemType),
+      };
+    } else {
+      referencedType = itemType;
+      propertySchema = {
+        type: 'array',
+        items: { $ref: `#/components/schemas/${itemType}` },
+      };
+    }
+  } else if (ASTAnalyzer.isMapType(field.type)) {
+    propertySchema = {
+      type: 'object',
+      additionalProperties: true,
+    };
+  } else if (isEnumType(field)) {
+    propertySchema = {
+      type: 'string',
+      enum: constraints.enumValues,
+    };
+  } else {
+    // Reference type
+    referencedType = field.type.split('.').pop() || field.type;
+    propertySchema = { $ref: `#/components/schemas/${referencedType}` };
+  }
+
+  // Apply constraints to schema
+  if (constraints.minLength !== undefined && propertySchema.type === 'string') {
+    propertySchema.minLength = constraints.minLength;
+  }
+  if (constraints.maxLength !== undefined && propertySchema.type === 'string') {
+    propertySchema.maxLength = constraints.maxLength;
+  }
+  if (constraints.minimum !== undefined && (propertySchema.type === 'integer' || propertySchema.type === 'number')) {
+    propertySchema.minimum = constraints.minimum;
+  }
+  if (constraints.maximum !== undefined && (propertySchema.type === 'integer' || propertySchema.type === 'number')) {
+    propertySchema.maximum = constraints.maximum;
+  }
+  if (constraints.pattern) {
+    propertySchema.pattern = constraints.pattern;
+  }
+
+  // Apply description: annotation description takes priority, then javadoc
+  if (constraints.description) {
+    propertySchema.description = constraints.description;
+  } else if (field.javadoc) {
+    propertySchema.description = field.javadoc;
+  }
+
+  return { propertySchema, isRequired, referencedType };
+}
+
+interface ValidationConstraints {
+  required: boolean;
+  minLength?: number;
+  maxLength?: number;
+  minimum?: number;
+  maximum?: number;
+  pattern?: string;
+  description?: string;
+  enumValues?: string[];
+}
+
+/**
+ * Extract validation constraints from field annotations
+ */
+function extractValidationConstraints(annotations: JavaAnnotation[]): ValidationConstraints {
+  const constraints: ValidationConstraints = { required: false };
+
+  for (const annotation of annotations) {
+    switch (annotation.name) {
+      case 'NotNull':
+      case 'NotEmpty':
+      case 'NotBlank':
+        constraints.required = true;
+        break;
+
+      case 'Size':
+        if (annotation.values['min']) {
+          constraints.minLength = parseInt(String(annotation.values['min']), 10);
+        }
+        if (annotation.values['max']) {
+          constraints.maxLength = parseInt(String(annotation.values['max']), 10);
+        }
+        break;
+
+      case 'Min':
+        if (annotation.values['value']) {
+          constraints.minimum = parseInt(String(annotation.values['value']), 10);
+        }
+        break;
+
+      case 'Max':
+        if (annotation.values['value']) {
+          constraints.maximum = parseInt(String(annotation.values['value']), 10);
+        }
+        break;
+
+      case 'Pattern':
+        if (annotation.values['regexp']) {
+          constraints.pattern = String(annotation.values['regexp']);
+        }
+        break;
+
+      case 'Email':
+        constraints.pattern = '^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$';
+        break;
+
+      case 'Length':
+        if (annotation.values['min']) {
+          constraints.minLength = parseInt(String(annotation.values['min']), 10);
+        }
+        if (annotation.values['max']) {
+          constraints.maxLength = parseInt(String(annotation.values['max']), 10);
+        }
+        break;
+
+      case 'Range':
+        if (annotation.values['min']) {
+          constraints.minimum = parseInt(String(annotation.values['min']), 10);
+        }
+        if (annotation.values['max']) {
+          constraints.maximum = parseInt(String(annotation.values['max']), 10);
+        }
+        break;
+
+      case 'ApiModelProperty':
+      case 'Schema':
+        if (annotation.values['description']) {
+          constraints.description = String(annotation.values['description']);
+        }
+        if (annotation.values['required'] === 'true' || annotation.values['required'] === true) {
+          constraints.required = true;
+        }
+        break;
+    }
+  }
+
+  return constraints;
+}
+
+/**
+ * Check if field is an enum type
+ */
+function isEnumType(field: JavaField): boolean {
+  // This is a simplified check - in practice, you'd need to analyze the type
+  const enumAnnotations = field.annotations.filter(
+    (a) => a.name === 'Enumerated' || (a.name === 'Schema' && a.values['allowableValues'])
+  );
+  return enumAnnotations.length > 0;
+}
+
+/**
+ * Extract main type from generic type string
+ */
+function extractMainType(genericType: string): string {
+  const match = genericType.match(/^([^<]+)/);
+  if (match) {
+    return match[1].trim();
+  }
+  return genericType;
+}

package/src/analyzer/securityAnalyzer.ts

@@ -0,0 +1,200 @@
+import { JavaMethod, JavaAnnotation, SecurityInfo } from '../types';
+import { ASTAnalyzer } from '../parser/astAnalyzer';
+
+/**
+ * Analyze method security annotations and extract roles/authorities
+ */
+export function analyzeMethodSecurity(method: JavaMethod): SecurityInfo {
+  const securityInfo: SecurityInfo = {
+    roles: [],
+    authorities: [],
+    hasComplexExpression: false,
+  };
+
+  const securityAnnotations = ASTAnalyzer.getSecurityAnnotations(method);
+
+  for (const annotation of securityAnnotations) {
+    switch (annotation.name) {
+      case 'PreAuthorize':
+      case 'PostAuthorize':
+        analyzeSpELExpression(annotation, securityInfo);
+        break;
+      case 'Secured':
+        analyzeSecuredAnnotation(annotation, securityInfo);
+        break;
+      case 'RolesAllowed':
+        analyzeRolesAllowedAnnotation(annotation, securityInfo);
+        break;
+    }
+  }
+
+  // Remove duplicates
+  securityInfo.roles = [...new Set(securityInfo.roles)];
+  securityInfo.authorities = [...new Set(securityInfo.authorities)];
+
+  return securityInfo;
+}
+
+/**
+ * Analyze @PreAuthorize / @PostAuthorize SpEL expression
+ */
+function analyzeSpELExpression(annotation: JavaAnnotation, securityInfo: SecurityInfo): void {
+  const expression = getAnnotationValue(annotation);
+  if (!expression) return;
+
+  // Extract hasRole() calls
+  const hasRoleMatches = expression.matchAll(/hasRole\s*\(\s*'([^']+)'\s*\)/g);
+  for (const match of hasRoleMatches) {
+    const role = normalizeRole(match[1]);
+    securityInfo.roles.push(role);
+  }
+
+  // Extract hasAnyRole() calls
+  const hasAnyRoleMatches = expression.matchAll(/hasAnyRole\s*\(\s*([^)]+)\s*\)/g);
+  for (const match of hasAnyRoleMatches) {
+    const rolesString = match[1];
+    const roles = extractRolesFromString(rolesString);
+    securityInfo.roles.push(...roles.map(normalizeRole));
+  }
+
+  // Extract hasAuthority() calls
+  const hasAuthorityMatches = expression.matchAll(/hasAuthority\s*\(\s*'([^']+)'\s*\)/g);
+  for (const match of hasAuthorityMatches) {
+    securityInfo.authorities.push(match[1]);
+  }
+
+  // Extract hasAnyAuthority() calls
+  const hasAnyAuthorityMatches = expression.matchAll(/hasAnyAuthority\s*\(\s*([^)]+)\s*\)/g);
+  for (const match of hasAnyAuthorityMatches) {
+    const authoritiesString = match[1];
+    const authorities = extractRolesFromString(authoritiesString);
+    securityInfo.authorities.push(...authorities);
+  }
+
+  // Check if the expression is complex (has more than just role/authority checks)
+  const isComplex = isComplexSpELExpression(expression);
+  if (isComplex) {
+    securityInfo.hasComplexExpression = true;
+    securityInfo.securityExpression = expression;
+  }
+}
+
+/**
+ * Analyze @Secured annotation
+ */
+function analyzeSecuredAnnotation(annotation: JavaAnnotation, securityInfo: SecurityInfo): void {
+  const value = annotation.values['value'];
+  if (!value) return;
+
+  const roles = Array.isArray(value) ? value : [value];
+  for (const role of roles) {
+    if (typeof role === 'string') {
+      securityInfo.roles.push(normalizeRole(role));
+    }
+  }
+}
+
+/**
+ * Analyze @RolesAllowed annotation
+ */
+function analyzeRolesAllowedAnnotation(annotation: JavaAnnotation, securityInfo: SecurityInfo): void {
+  const value = annotation.values['value'];
+  if (!value) return;
+
+  const roles = Array.isArray(value) ? value : [value];
+  for (const role of roles) {
+    if (typeof role === 'string') {
+      securityInfo.roles.push(normalizeRole(role));
+    }
+  }
+}
+
+/**
+ * Get annotation value
+ */
+function getAnnotationValue(annotation: JavaAnnotation): string | undefined {
+  const value = annotation.values['value'];
+  if (value === undefined) return undefined;
+
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+
+  return typeof value === 'string' ? value : String(value);
+}
+
+/**
+ * Normalize role name to include ROLE_ prefix if not present
+ */
+function normalizeRole(role: string): string {
+  const trimmedRole = role.trim().replace(/^['"]|['"]$/g, '');
+
+  if (trimmedRole.startsWith('ROLE_')) {
+    return trimmedRole;
+  }
+
+  return `ROLE_${trimmedRole}`;
+}
+
+/**
+ * Extract roles from a comma-separated string with quotes
+ * e.g., "'USER', 'ADMIN'" -> ["USER", "ADMIN"]
+ */
+function extractRolesFromString(rolesString: string): string[] {
+  const roles: string[] = [];
+  const matches = rolesString.matchAll(/'([^']+)'/g);
+
+  for (const match of matches) {
+    roles.push(match[1]);
+  }
+
+  return roles;
+}
+
+/**
+ * Check if a SpEL expression is complex
+ * (contains more than just hasRole/hasAnyRole/hasAuthority/hasAnyAuthority)
+ */
+function isComplexSpELExpression(expression: string): boolean {
+  // Remove all simple role/authority checks
+  let simplified = expression
+    .replace(/hasRole\s*\(\s*'[^']+'\s*\)/g, '')
+    .replace(/hasAnyRole\s*\(\s*[^)]+\s*\)/g, '')
+    .replace(/hasAuthority\s*\(\s*'[^']+'\s*\)/g, '')
+    .replace(/hasAnyAuthority\s*\(\s*[^)]+\s*\)/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  // Remove boolean operators that might remain
+  simplified = simplified
+    .replace(/^\s*and\s*/gi, '')
+    .replace(/\s*and\s*$/gi, '')
+    .replace(/^\s*or\s*/gi, '')
+    .replace(/\s*or\s*$/gi, '')
+    .replace(/^\s*&&\s*/g, '')
+    .replace(/\s*&&\s*$/g, '')
+    .replace(/^\s*\|\|\s*/g, '')
+    .replace(/\s*\|\|\s*$/g, '')
+    .replace(/^\s*\(\s*\)\s*$/g, '')
+    .trim();
+
+  // If anything remains (other than parentheses and whitespace), it's complex
+  const hasOtherContent = simplified.replace(/[()]/g, '').trim().length > 0;
+
+  // Also check for specific complex patterns
+  const complexPatterns = [
+    /#\w+/, // Variable references like #user, #id
+    /\.\w+/, // Property access
+    /==|!=|<|>|<=|>=/, // Comparison operators
+    /isAuthenticated\(\)/, // Authentication checks
+    /isAnonymous\(\)/, // Anonymous checks
+    /permitAll\(\)/, // Permit all
+    /denyAll\(\)/, // Deny all
+    /authentication\./i, // Authentication object access
+    /principal\./i, // Principal object access
+  ];
+
+  const hasComplexPattern = complexPatterns.some((pattern) => pattern.test(expression));
+
+  return hasOtherContent || hasComplexPattern;
+}