@saptools/service-flow 0.1.50 → 0.1.52

package/src/output/table-output.ts

@@ -24,12 +24,36 @@ export function renderTraceTable(result: TraceResult): string {
 
 function diagnosticLines(diagnostic: Record<string, unknown>): string[] {
   const first = `${String(diagnostic.severity ?? 'info')} ${String(diagnostic.code ?? 'diagnostic')} ${String(diagnostic.message ?? '')}`;
-  return [first, ...hintLines(diagnostic).map((hint) => `  ${hint}`)];
+  const details = diagnosticDetailLines(diagnostic);
+  return [first, ...[...details, ...hintLines(diagnostic)]
+    .map((hint) => `  ${hint}`)];
+}
+
+function diagnosticDetailLines(diagnostic: Record<string, unknown>): string[] {
+  const lines: string[] = [];
+  if (diagnostic.sourceFile || diagnostic.sourceLine)
+    lines.push(`at ${String(diagnostic.sourceFile ?? '')}:${String(diagnostic.sourceLine ?? '')}`);
+  const unsupported = stringList(diagnostic.unsupportedDecoratorNames);
+  const observed = stringList(diagnostic.observedDecoratorNames);
+  if (unsupported.length > 0)
+    lines.push(`unsupported decorators: ${unsupported.join(', ')}`);
+  else if (observed.length > 0)
+    lines.push(`observed decorators: ${observed.join(', ')}`);
+  if (typeof diagnostic.remediation === 'string')
+    lines.push(`hint: ${diagnostic.remediation}`);
+  return lines;
+}
+
+function stringList(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
 }
 
 function hintLines(evidence: Record<string, unknown>): string[] {
+  const dynamicLines = dynamicHintLines(evidence);
   const suggestions = evidence.implementationHintSuggestions;
-  if (!Array.isArray(suggestions)) return [];
+  if (!Array.isArray(suggestions)) return dynamicLines;
   const hints = suggestions.flatMap((item) =>
     isRecord(item) && typeof item.cli === 'string'
       ? [item.cli]
@@ -38,9 +62,38 @@ function hintLines(evidence: Record<string, unknown>): string[] {
   const shown = unique.slice(0, 3).map((hint) => `try ${hint}`);
   if (unique.length > shown.length)
     shown.push(`... ${unique.length - shown.length} more hint(s) available in JSON`);
-  return shown;
+  return [...dynamicLines, ...shown];
+}
+
+function dynamicHintLines(evidence: Record<string, unknown>): string[] {
+  const exploration = isRecord(evidence.dynamicTargetExploration)
+    ? evidence.dynamicTargetExploration
+    : evidence;
+  const count = numberValue(exploration.candidateCount);
+  if (count === 0) return [];
+  const shown = numberValue(exploration.shownCandidateCount);
+  const omitted = numberValue(exploration.omittedCandidateCount);
+  const rejected = numberValue(exploration.rejectedCandidateCount);
+  const lines = [
+    `viable candidates: ${shown} shown, ${omitted} omitted; rejected: ${rejected}`,
+  ];
+  lines.push(...varSetHints(exploration.suggestedVarSets));
+  if (omitted > 0 || rejected > 0 || shown < count)
+    lines.push('use --dynamic-mode candidates --max-dynamic-candidates 20 to explore candidate branches');
+  return lines;
+}
+
+function varSetHints(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const hints = value.flatMap((item) =>
+    isRecord(item) && typeof item.cli === 'string' ? [`try ${item.cli}`] : []);
+  return [...new Set(hints)].slice(0, 3);
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
+
+function numberValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}

package/src/parsers/cds-parser.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import type { CdsOperationFact, CdsServiceFact } from '../types.js';
 import { ensureLeadingSlash, normalizePath } from '../utils/path-utils.js';
+import type { RepositorySourceContext } from './ts-project.js';
 
 function lineOf(text: string, index: number): number {
   return text.slice(0, index).split('\n').length;
@@ -136,9 +137,14 @@ function operationsFromBody(text: string, maskedBody: string, bodyOffset: number
   }));
 }
 
-export async function parseCdsFile(repoPath: string, filePath: string): Promise<CdsServiceFact[]> {
+export async function parseCdsFile(
+  repoPath: string,
+  filePath: string,
+  context?: RepositorySourceContext,
+): Promise<CdsServiceFact[]> {
   const absolute = path.join(repoPath, filePath);
-  const text = await fs.readFile(absolute, 'utf8');
+  const text = context?.get(filePath)?.text
+    ?? await fs.readFile(absolute, 'utf8');
   const masked = maskCommentsAndStrings(text);
   const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
   const services: CdsServiceFact[] = [];

package/src/parsers/decorator-parser.ts

@@ -1,17 +1,65 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import ts from 'typescript';
-import type { HandlerClassFact, HandlerMethodFact } from '../types.js';
+import type {
+  HandlerClassFact,
+  HandlerLifecycleEvent,
+  HandlerLifecyclePhase,
+  HandlerMethodFact,
+  HandlerMethodKind,
+} from '../types.js';
 import { generatedOperationNameFromConstant } from '../linker/operation-decorator-normalizer.js';
-import { createSourceFile } from './ts-project.js';
+import {
+  createSourceFile,
+  type RepositorySourceContext,
+} from './ts-project.js';
 import { normalizePath } from '../utils/path-utils.js';
 
 type DecoratorResolution = HandlerMethodFact['decoratorResolution'];
+type ResolvedArgumentKind = Exclude<
+  DecoratorResolution['resolutionKind'],
+  'lifecycle_implicit' | 'unresolved'
+>;
 interface StringLookups {
   identifiers: Map<string, string>;
   enumMembers: Map<string, string>;
   objectProperties: Map<string, string>;
+  capDecoratorNames: Map<string, string>;
+  capDecoratorNamespaces: Set<string>;
 }
+interface LifecycleMetadata {
+  phase: HandlerLifecyclePhase;
+  event: HandlerLifecycleEvent;
+}
+interface MethodClassification {
+  handlerKind: HandlerMethodKind;
+  executable: boolean;
+  lifecyclePhase?: HandlerLifecyclePhase;
+  lifecycleEvent?: HandlerLifecycleEvent;
+}
+interface ParsedMethodDecorator {
+  classification: MethodClassification;
+  resolution: DecoratorResolution;
+  decoratorKind: string;
+  importedKind?: string;
+}
+
+const OPERATION_DECORATORS = new Set(['Action', 'Func', 'On']);
+const EVENT_DECORATORS = new Set(['Event']);
+const LIFECYCLE_DECORATORS = new Map<string, LifecycleMetadata>([
+  ['BeforeCreate', { phase: 'before', event: 'CREATE' }],
+  ['OnCreate', { phase: 'on', event: 'CREATE' }],
+  ['AfterCreate', { phase: 'after', event: 'CREATE' }],
+  ['BeforeRead', { phase: 'before', event: 'READ' }],
+  ['OnRead', { phase: 'on', event: 'READ' }],
+  ['AfterRead', { phase: 'after', event: 'READ' }],
+  ['BeforeUpdate', { phase: 'before', event: 'UPDATE' }],
+  ['OnUpdate', { phase: 'on', event: 'UPDATE' }],
+  ['AfterUpdate', { phase: 'after', event: 'UPDATE' }],
+  ['BeforeDelete', { phase: 'before', event: 'DELETE' }],
+  ['OnDelete', { phase: 'on', event: 'DELETE' }],
+  ['AfterDelete', { phase: 'after', event: 'DELETE' }],
+]);
 
 function line(sf: ts.SourceFile, pos: number): number {
   return sf.getLineAndCharacterOfPosition(pos).line + 1;
@@ -27,6 +75,15 @@ function firstArg(d: ts.Decorator): ts.Expression | undefined {
   const e = d.expression;
   return ts.isCallExpression(e) ? e.arguments[0] : undefined;
 }
+function decoratorArguments(d: ts.Decorator): readonly ts.Expression[] | undefined {
+  return ts.isCallExpression(d.expression) ? d.expression.arguments : undefined;
+}
+function methodName(name: ts.PropertyName): string {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name)
+    ? name.text
+    : name.getText();
+}
 function unwrapExpression(expression: ts.Expression): ts.Expression {
   let current = expression;
   while (
@@ -77,8 +134,11 @@ function collectStringLookups(source: ts.SourceFile): StringLookups {
     identifiers: new Map(),
     enumMembers: new Map(),
     objectProperties: new Map(),
+    capDecoratorNames: new Map(),
+    capDecoratorNamespaces: new Set(),
   };
   for (const statement of source.statements) {
+    collectCapDecoratorImports(statement, lookups);
     if (ts.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
     if (!ts.isVariableStatement(statement)
       || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
@@ -91,8 +151,62 @@ function collectStringLookups(source: ts.SourceFile): StringLookups {
   }
   return lookups;
 }
-function unresolved(rawExpression: string, reason: string): DecoratorResolution {
-  return { rawExpression, resolutionKind: 'unresolved', unresolvedReason: reason };
+function collectCapDecoratorImports(
+  statement: ts.Statement,
+  lookups: StringLookups,
+): void {
+  if (!ts.isImportDeclaration(statement)
+    || !ts.isStringLiteral(statement.moduleSpecifier)
+    || statement.moduleSpecifier.text !== 'cds-routing-handlers') return;
+  const clause = statement.importClause;
+  if (!clause || clause.isTypeOnly) return;
+  const bindings = clause.namedBindings;
+  if (bindings && ts.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      if (element.isTypeOnly) continue;
+      lookups.capDecoratorNames.set(
+        element.name.text,
+        element.propertyName?.text ?? element.name.text,
+      );
+    }
+  }
+  if (bindings && ts.isNamespaceImport(bindings))
+    lookups.capDecoratorNamespaces.add(bindings.name.text);
+}
+function capDecoratorName(
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+): string | undefined {
+  const expression = ts.isCallExpression(decorator.expression)
+    ? decorator.expression.expression
+    : decorator.expression;
+  if (ts.isIdentifier(expression))
+    return lookups.capDecoratorNames.get(expression.text);
+  if (ts.isPropertyAccessExpression(expression)
+    && ts.isIdentifier(expression.expression)
+    && lookups.capDecoratorNamespaces.has(expression.expression.text))
+    return expression.name.text;
+  return undefined;
+}
+function unresolved(
+  rawExpression: string,
+  reason: string,
+  argumentExpression?: string,
+): DecoratorResolution {
+  return {
+    rawExpression,
+    argumentExpression,
+    resolutionKind: 'unresolved',
+    unresolvedReason: reason,
+  };
+}
+function resolved(
+  rawExpression: string,
+  argumentExpression: string,
+  resolvedValue: string,
+  resolutionKind: ResolvedArgumentKind,
+): DecoratorResolution {
+  return { rawExpression, argumentExpression, resolvedValue, resolutionKind };
 }
 function generatedConstant(rawExpression: string): string | undefined {
   const match = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/
@@ -104,76 +218,296 @@ function generatedConstant(rawExpression: string): string | undefined {
 function resolveDecoratorArgument(
   argument: ts.Expression | undefined,
   lookups: StringLookups,
+  rawExpression: string,
 ): DecoratorResolution {
-  if (!argument) return unresolved('', 'decorator_argument_missing');
-  const rawExpression = argument.getText();
+  if (!argument) return unresolved(rawExpression, 'decorator_argument_missing');
+  const argumentExpression = argument.getText();
   const expression = unwrapExpression(argument);
   if (ts.isStringLiteralLike(expression))
-    return { rawExpression, resolvedValue: expression.text, resolutionKind: 'literal' };
+    return resolved(rawExpression, argumentExpression, expression.text, 'literal');
   if (ts.isIdentifier(expression)) {
     const value = lookups.identifiers.get(expression.text);
     return value === undefined
-      ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string')
-      : { rawExpression, resolvedValue: value, resolutionKind: 'const_identifier' };
+      ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string', argumentExpression)
+      : resolved(rawExpression, argumentExpression, value, 'const_identifier');
   }
   if (ts.isPropertyAccessExpression(expression)
     && ts.isIdentifier(expression.expression)) {
     const key = `${expression.expression.text}.${expression.name.text}`;
     const enumValue = lookups.enumMembers.get(key);
     if (enumValue !== undefined)
-      return { rawExpression, resolvedValue: enumValue, resolutionKind: 'enum_member' };
+      return resolved(rawExpression, argumentExpression, enumValue, 'enum_member');
     const objectValue = lookups.objectProperties.get(key);
     if (objectValue !== undefined)
-      return { rawExpression, resolvedValue: objectValue, resolutionKind: 'const_object_property' };
+      return resolved(rawExpression, argumentExpression, objectValue, 'const_object_property');
   }
-  const generatedValue = generatedConstant(rawExpression);
+  const generatedValue = generatedConstant(argumentExpression);
   if (generatedValue !== undefined)
-    return {
+    return resolved(
       rawExpression,
-      resolvedValue: generatedValue,
-      resolutionKind: 'generated_constant_name',
-    };
+      argumentExpression,
+      generatedValue,
+      'generated_constant_name',
+    );
   if (ts.isPropertyAccessExpression(expression))
-    return unresolved(rawExpression, 'property_access_not_resolved_to_local_string');
-  return unresolved(rawExpression, 'unsupported_decorator_expression');
+    return unresolved(
+      rawExpression,
+      'property_access_not_resolved_to_local_string',
+      argumentExpression,
+    );
+  return unresolved(rawExpression, 'unsupported_decorator_expression', argumentExpression);
+}
+function classificationFor(name: string): MethodClassification | undefined {
+  if (OPERATION_DECORATORS.has(name))
+    return { handlerKind: 'operation', executable: true };
+  if (EVENT_DECORATORS.has(name))
+    return { handlerKind: 'event', executable: true };
+  const lifecycle = LIFECYCLE_DECORATORS.get(name);
+  if (!lifecycle) return undefined;
+  return {
+    handlerKind: 'entity_lifecycle',
+    executable: true,
+    lifecyclePhase: lifecycle.phase,
+    lifecycleEvent: lifecycle.event,
+  };
+}
+function lifecycleLikePhase(name: string): HandlerLifecyclePhase | undefined {
+  if (/^On[A-Z]/.test(name)) return 'on';
+  if (/^Before[A-Z]/.test(name)) return 'before';
+  if (/^After[A-Z]/.test(name)) return 'after';
+  return undefined;
+}
+function withClassification(
+  resolution: DecoratorResolution,
+  classification: MethodClassification,
+): DecoratorResolution {
+  return {
+    ...resolution,
+    handlerKind: classification.handlerKind,
+    executable: classification.executable,
+    lifecyclePhase: classification.lifecyclePhase,
+    lifecycleEvent: classification.lifecycleEvent,
+  };
+}
+function withDecoratorEvidence(
+  resolution: DecoratorResolution,
+  decorator: ts.Decorator,
+  resolvedDecoratorKind: string | undefined,
+): DecoratorResolution {
+  return {
+    ...resolution,
+    decoratorExpression: decorator.expression.getText(),
+    resolvedDecoratorKind,
+    decoratorImportSource: resolvedDecoratorKind
+      ? 'cds-routing-handlers'
+      : undefined,
+  };
+}
+function lifecycleDecoratorResolution(
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+  classification: MethodClassification,
+): { classification: MethodClassification; resolution: DecoratorResolution } {
+  const rawExpression = decorator.expression.getText();
+  const args = decoratorArguments(decorator);
+  if (args?.length === 0)
+    return {
+      classification,
+      resolution: withClassification({
+        rawExpression,
+        resolutionKind: 'lifecycle_implicit',
+      }, classification),
+    };
+  const resolution = args?.length === 1
+    ? resolveDecoratorArgument(args[0], lookups, rawExpression)
+    : unresolved(rawExpression, args ? 'unsupported_lifecycle_argument_count' : 'lifecycle_decorator_call_required');
+  const unsupported = { ...classification, handlerKind: 'unsupported_lifecycle', executable: false } as const;
+  const unsupportedResolution = args?.length === 1
+    ? { ...resolution, unresolvedReason: 'lifecycle_decorator_arguments_not_supported' }
+    : resolution;
+  return {
+    classification: unsupported,
+    resolution: withClassification(unsupportedResolution, unsupported),
+  };
+}
+function unsupportedLifecycleResolution(
+  decorator: ts.Decorator,
+  phase: HandlerLifecyclePhase,
+): { classification: MethodClassification; resolution: DecoratorResolution } {
+  const classification: MethodClassification = {
+    handlerKind: 'unsupported_lifecycle',
+    executable: false,
+    lifecyclePhase: phase,
+  };
+  const resolution = unresolved(
+    decorator.expression.getText(),
+    'lifecycle_decorator_not_allowlisted',
+  );
+  return { classification, resolution: withClassification(resolution, classification) };
+}
+function unsupportedDecoratorResolution(
+  decorator: ts.Decorator,
+  reason: string,
+  phase?: HandlerLifecyclePhase,
+): { classification: MethodClassification; resolution: DecoratorResolution } {
+  const classification: MethodClassification = {
+    handlerKind: phase ? 'unsupported_lifecycle' : 'unsupported_decorator',
+    executable: false,
+    lifecyclePhase: phase,
+  };
+  return {
+    classification,
+    resolution: withClassification(
+      unresolved(decorator.expression.getText(), reason),
+      classification,
+    ),
+  };
+}
+function parseMethodDecorator(
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+  handlerClass: boolean,
+  allowLifecycle: boolean,
+): ParsedMethodDecorator | undefined {
+  const decoratorKind = callName(decorator);
+  const importedKind = capDecoratorName(decorator, lookups);
+  const resolvedKind = importedKind ?? decoratorKind;
+  const base = classificationFor(resolvedKind);
+  const phase = lifecycleLikePhase(resolvedKind);
+  const isLifecycle = base?.handlerKind === 'entity_lifecycle' || Boolean(phase && !base);
+  if (!handlerClass && isLifecycle) return undefined;
+  const parsed = isLifecycle && (!allowLifecycle || !importedKind)
+    ? unsupportedDecoratorResolution(
+        decorator, 'lifecycle_decorator_import_not_supported', phase,
+      )
+    : base?.handlerKind === 'entity_lifecycle'
+      ? lifecycleDecoratorResolution(decorator, lookups, base)
+      : phase && !base
+        ? unsupportedLifecycleResolution(decorator, phase)
+        : !base && handlerClass
+          ? unsupportedDecoratorResolution(decorator, 'decorator_not_allowlisted')
+          : {
+              classification: base,
+              resolution: resolveDecoratorArgument(
+                firstArg(decorator),
+                lookups,
+                firstArg(decorator)?.getText() ?? decorator.expression.getText(),
+              ),
+            };
+  if (!parsed.classification) return undefined;
+  return {
+    classification: parsed.classification,
+    resolution: parsed.resolution,
+    decoratorKind,
+    importedKind,
+  };
+}
+function methodDecoratorFact(
+  method: ts.MethodDeclaration,
+  decorator: ts.Decorator,
+  lookups: StringLookups,
+  source: ts.SourceFile,
+  filePath: string,
+  handlerClass: boolean,
+  allowLifecycle: boolean,
+): HandlerMethodFact | undefined {
+  const parsed = parseMethodDecorator(decorator, lookups, handlerClass, allowLifecycle);
+  if (!parsed) return undefined;
+  const classification = method.body
+    ? parsed.classification
+    : { ...parsed.classification, executable: false };
+  const resolution = method.body
+    ? parsed.resolution
+    : { ...parsed.resolution, unresolvedReason: 'handler_method_body_missing' };
+  const argumentExpression = firstArg(decorator)?.getText();
+  return {
+    methodName: methodName(method.name),
+    decoratorKind: parsed.decoratorKind,
+    decoratorValue: parsed.resolution.resolvedValue,
+    decoratorRawExpression: argumentExpression ?? decorator.expression.getText(),
+    handlerKind: classification.handlerKind,
+    executable: classification.executable,
+    lifecyclePhase: classification.lifecyclePhase,
+    lifecycleEvent: classification.lifecycleEvent,
+    decoratorResolution: withDecoratorEvidence(
+      withClassification(resolution, classification),
+      decorator,
+      parsed.importedKind,
+    ),
+    sourceFile: normalizePath(filePath),
+    sourceLine: line(source, method.getStart()),
+  };
+}
+function unique(values: string[]): string[] {
+  return [...new Set(values)];
+}
+function parseClassMethods(
+  node: ts.ClassDeclaration,
+  lookups: StringLookups,
+  source: ts.SourceFile,
+  filePath: string,
+  handlerClass: boolean,
+  allowLifecycle: boolean,
+): Pick<HandlerClassFact, 'methods' | 'observedDecoratorNames' | 'unsupportedDecoratorNames'> {
+  const methods: HandlerMethodFact[] = [];
+  const observed: string[] = [];
+  const unsupported: string[] = [];
+  for (const method of node.members.filter(ts.isMethodDeclaration)) {
+    for (const decorator of decs(method)) {
+      observed.push(callName(decorator));
+      const fact = methodDecoratorFact(
+        method, decorator, lookups, source, filePath, handlerClass, allowLifecycle,
+      );
+      if (fact) methods.push(fact);
+      if (!fact?.executable) unsupported.push(callName(decorator));
+    }
+  }
+  return {
+    methods,
+    observedDecoratorNames: unique(observed),
+    unsupportedDecoratorNames: unique(unsupported),
+  };
+}
+function parseHandlerClass(
+  node: ts.ClassDeclaration,
+  lookups: StringLookups,
+  source: ts.SourceFile,
+  filePath: string,
+): HandlerClassFact | undefined {
+  const classDecoratorNames = unique(decs(node).map(callName));
+  const classDecorators = decs(node);
+  const hasImportedHandler = classDecorators.some((decorator) =>
+    capDecoratorName(decorator, lookups) === 'Handler');
+  const hasHandlerDecorator = hasImportedHandler
+    || classDecoratorNames.includes('Handler');
+  const parsed = parseClassMethods(
+    node, lookups, source, filePath, hasHandlerDecorator, hasImportedHandler,
+  );
+  if (!hasHandlerDecorator && parsed.methods.length === 0) return undefined;
+  return {
+    className: node.name?.text ?? 'AnonymousHandler',
+    sourceFile: normalizePath(filePath),
+    sourceLine: line(source, node.getStart()),
+    ...parsed,
+    hasHandlerDecorator,
+    classDecoratorNames,
+  };
 }
 export async function parseDecorators(
   repoPath: string,
-  filePath: string
+  filePath: string,
+  context?: RepositorySourceContext,
 ): Promise<HandlerClassFact[]> {
-  const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
-  const sf = createSourceFile(filePath, text);
+  const snapshot = context?.get(filePath);
+  const text = snapshot?.text
+    ?? await fs.readFile(path.join(repoPath, filePath), 'utf8');
+  const sf = snapshot?.sourceFile() ?? createSourceFile(filePath, text);
   const lookups = collectStringLookups(sf);
   const handlers: HandlerClassFact[] = [];
   function visit(node: ts.Node): void {
     if (ts.isClassDeclaration(node)) {
-      const className = node.name?.text ?? 'AnonymousHandler';
-      const hasHandler = decs(node).some((d) => callName(d) === 'Handler');
-      const methods = node.members.filter(ts.isMethodDeclaration).flatMap((m) =>
-        decs(m)
-          .filter((d) =>
-            ['Func', 'Action', 'On', 'Event'].includes(callName(d))
-          )
-          .map((d) => {
-            const decoratorResolution = resolveDecoratorArgument(firstArg(d), lookups);
-            return {
-              methodName: m.name.getText(),
-              decoratorKind: callName(d),
-              decoratorValue: decoratorResolution.resolvedValue,
-              decoratorRawExpression: decoratorResolution.rawExpression,
-              decoratorResolution,
-              sourceFile: normalizePath(filePath),
-              sourceLine: line(sf, m.getStart())
-            };
-          })
-      );
-      if (hasHandler || methods.length > 0)
-        handlers.push({
-          className,
-          sourceFile: normalizePath(filePath),
-          sourceLine: line(sf, node.getStart()),
-          methods
-        });
+      const handler = parseHandlerClass(node, lookups, sf, filePath);
+      if (handler) handlers.push(handler);
     }
     ts.forEachChild(node, visit);
   }