@goboost/scanner-typescript 1.2.1

package/src/unsupported-detector.ts

@@ -0,0 +1,253 @@
+/**
+ * Unsupported feature detector - flags routes using V2 features
+ * Scans for @UseInterceptors, @UsePipes, @UseFilters, custom decorators
+ */
+import { Project, SourceFile, ClassDeclaration, MethodDeclaration, Decorator } from 'ts-morph';
+
+interface RouteMapping {
+  handlerName: string;
+  unsupportedFeatures: string[];
+}
+
+// V1 unsupported decorators
+const UNSUPPORTED_DECORATORS = [
+  'UseInterceptors',
+  'UsePipes',
+  'UseFilters',
+  'SetMetadata',
+  'Redirect',
+  'Render',
+];
+
+// Parameter decorators that are not supported
+const UNSUPPORTED_PARAM_DECORATORS = [
+  'Req',
+  'Res',
+  'Next',
+  'Session',
+  'Headers',
+  'Ip',
+  'HostParam',
+];
+
+// Patterns that indicate complex async behavior
+const UNSUPPORTED_PATTERNS = [
+  'EventEmitter',
+  'Observable',
+  'MessagePattern',
+  'EventPattern',
+  'WebSocket',
+  'WsGateway',
+];
+
+/**
+ * Detect unsupported features for a specific route
+ */
+export function detectUnsupported(
+  project: Project,
+  route: RouteMapping
+): string[] {
+  const unsupported: string[] = [];
+
+  // Find the method in the project
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const classDecl of sourceFile.getClasses()) {
+      const method = classDecl.getMethod(route.handlerName);
+      if (method) {
+        collectUnsupportedDecorators(method, unsupported);
+        collectUnsupportedParamDecorators(method, unsupported);
+        collectUnsupportedPatterns(method, unsupported);
+        return unsupported;
+      }
+    }
+  }
+
+  return unsupported;
+}
+
+/**
+ * Detect unsupported features for all routes in a controller class
+ */
+export function detectUnsupportedForController(
+  classDecl: ClassDeclaration
+): Map<string, string[]> {
+  const routeUnsupported = new Map<string, string[]>();
+
+  for (const method of classDecl.getMethods()) {
+    const methodName = method.getName();
+
+    // Only check methods that are route handlers (have HTTP method decorators)
+    const httpDecorators = ['Get', 'Post', 'Put', 'Delete', 'Patch'];
+    const hasHttpDecorator = method.getDecorators().some(d =>
+      httpDecorators.includes(d.getName())
+    );
+
+    if (hasHttpDecorator) {
+      const unsupported: string[] = [];
+      collectUnsupportedDecorators(method, unsupported);
+      collectUnsupportedParamDecorators(method, unsupported);
+      collectUnsupportedPatterns(method, unsupported);
+
+      if (unsupported.length > 0) {
+        routeUnsupported.set(methodName, unsupported);
+      }
+    }
+  }
+
+  return routeUnsupported;
+}
+
+/**
+ * Check if a class has any controller-level unsupported features
+ */
+export function detectClassLevelUnsupported(classDecl: ClassDeclaration): string[] {
+  const unsupported: string[] = [];
+
+  for (const decorator of classDecl.getDecorators()) {
+    const name = decorator.getName();
+    if (UNSUPPORTED_DECORATORS.includes(name)) {
+      unsupported.push(`${name} decorator at class level`);
+    }
+  }
+
+  return unsupported;
+}
+
+function collectUnsupportedDecorators(
+  method: MethodDeclaration,
+  unsupported: string[]
+): void {
+  const decorators = method.getDecorators();
+
+  for (const decorator of decorators) {
+    const name = decorator.getName();
+
+    // Check for unsupported method decorators
+    if (UNSUPPORTED_DECORATORS.includes(name)) {
+      const feature = getFeatureName(name);
+      if (!unsupported.includes(feature)) {
+        unsupported.push(feature);
+      }
+    }
+
+    // Check for custom decorators (not standard NestJS)
+    if (isCustomDecorator(decorator)) {
+      const customFeature = `custom decorator: ${name}`;
+      if (!unsupported.includes(customFeature)) {
+        unsupported.push(customFeature);
+      }
+    }
+  }
+}
+
+function collectUnsupportedParamDecorators(
+  method: MethodDeclaration,
+  unsupported: string[]
+): void {
+  for (const param of method.getParameters()) {
+    for (const decorator of param.getDecorators()) {
+      const name = decorator.getName();
+      if (UNSUPPORTED_PARAM_DECORATORS.includes(name)) {
+        const feature = `${name}() parameter`;
+        if (!unsupported.includes(feature)) {
+          unsupported.push(feature);
+        }
+      }
+    }
+  }
+}
+
+function collectUnsupportedPatterns(
+  method: MethodDeclaration,
+  unsupported: string[]
+): void {
+  const bodyText = method.getBodyText();
+  if (!bodyText) return;
+
+  for (const pattern of UNSUPPORTED_PATTERNS) {
+    if (bodyText.includes(pattern)) {
+      const feature = `complex pattern: ${pattern}`;
+      if (!unsupported.includes(feature)) {
+        unsupported.push(feature);
+      }
+    }
+  }
+
+  // Check for file upload patterns
+  if (bodyText.includes('FileInterceptor') || bodyText.includes('FilesInterceptor') ||
+      bodyText.includes('UploadedFile') || bodyText.includes('UploadedFiles')) {
+    const feature = 'file upload';
+    if (!unsupported.includes(feature)) {
+      unsupported.push(feature);
+    }
+  }
+
+  // Check for SSE/WebSocket patterns
+  if (bodyText.includes('Sse') || bodyText.includes('MessageEvent')) {
+    const feature = 'Server-Sent Events';
+    if (!unsupported.includes(feature)) {
+      unsupported.push(feature);
+    }
+  }
+}
+
+function getFeatureName(decoratorName: string): string {
+  const featureMap: Record<string, string> = {
+    'UseInterceptors': 'interceptor',
+    'UsePipes': 'pipe',
+    'UseFilters': 'exception filter',
+    'SetMetadata': 'custom metadata',
+    'Redirect': 'redirect',
+    'Render': 'view rendering',
+  };
+
+  return featureMap[decoratorName] || decoratorName.toLowerCase();
+}
+
+function isCustomDecorator(decorator: Decorator): boolean {
+  const knownDecorators = [
+    // HTTP methods
+    'Get', 'Post', 'Put', 'Delete', 'Patch', 'Options', 'Head', 'All',
+    // Parameters
+    'Body', 'Query', 'Param', 'Headers', 'Ip', 'HostParam',
+    // Guards
+    'UseGuards',
+    // Common
+    'HttpCode', 'Header', 'Redirect', 'Render',
+    // NestJS core
+    'Injectable', 'Controller', 'Module', 'Inject',
+    // Hybrid
+    'HybridRoute',
+    // Validation
+    ...getValidationDecorators(),
+  ];
+
+  return !knownDecorators.includes(decorator.getName());
+}
+
+function getValidationDecorators(): string[] {
+  return [
+    'IsString', 'IsNumber', 'IsEmail', 'IsInt', 'IsBoolean',
+    'Min', 'Max', 'MinLength', 'MaxLength', 'IsOptional',
+    'IsDate', 'IsArray', 'IsEnum', 'IsUUID', 'IsUrl',
+    'Matches', 'IsNotEmpty', 'IsDefined', 'IsPositive',
+  ];
+}
+
+/**
+ * Check if a route can be generated (no unsupported features)
+ */
+export function canGenerate(unsupportedFeatures: string[]): boolean {
+  return unsupportedFeatures.length === 0;
+}
+
+/**
+ * Get a human-readable summary of unsupported features
+ */
+export function getUnsupportedSummary(unsupportedFeatures: string[]): string {
+  if (unsupportedFeatures.length === 0) {
+    return 'All features supported';
+  }
+
+  return `Unsupported features: ${unsupportedFeatures.join(', ')}`;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}