@saptools/service-flow 0.1.70 → 0.1.72

package/src/parsers/outbound-call-classifier.ts

@@ -11,11 +11,9 @@ import {
   variableInitializers,
 } from './query-entity-resolution.js';
 import {
-  CDS_LIFECYCLE_EVENTS,
   calledWrapperNames,
   collectServiceVariables,
   externalHttpEvidence,
-  isSupportedEventReceiver,
   legacyPathCandidates,
   lineOf,
   literalPathSource,
@@ -35,6 +33,17 @@ import {
   type ExpressionResolution,
   type WrapperSpec,
 } from './outbound-expression-analysis.js';
+import {
+  analyzeEventCall,
+  createEventCallAnalysisContext,
+  type EventCallAnalysisContext,
+} from './event-call-analysis.js';
+import type {
+  ImportedEventNameResolver,
+} from './event-name-import-resolution.js';
+import type {
+  EventEnvironmentReferenceResolver,
+} from './event-environment-reference.js';
 import {
   analyzeOperationPath,
   operationPathExpression,
@@ -47,6 +56,11 @@ export interface ClassifiedOutboundCall {
   node: ts.CallExpression;
 }
 
+export interface OutboundClassificationOptions {
+  importedEventNameResolver?: ImportedEventNameResolver;
+  eventEnvironmentReferenceResolver?: EventEnvironmentReferenceResolver;
+}
+
 function namedFunctionLike(
   node: ts.Node,
 ): { name: string; fn: ts.FunctionLikeDeclaration } | undefined {
@@ -79,122 +93,6 @@ function collectWrapperSpecs(
   return specs;
 }
 
-interface EventCallClassification {
-  fact: Pick<OutboundCallFact,
-    'callType' | 'serviceVariableName' | 'eventNameExpr'
-    | 'confidence' | 'unresolvedReason'>;
-  evidence: Record<string, unknown>;
-}
-
-interface EventReceiver {
-  effectiveReceiver: string;
-  receiver?: string;
-  rootReceiver?: string;
-}
-
-function eventReceiver(
-  expression: ts.PropertyAccessExpression,
-  serviceVariables: Set<string>,
-): EventReceiver | undefined {
-  const receiver = receiverName(expression.expression);
-  const rootReceiver = rootReceiverName(expression.expression);
-  if (!isSupportedEventReceiver(receiver, rootReceiver, serviceVariables))
-    return undefined;
-  const effectiveReceiver = rootReceiver ?? receiver;
-  return effectiveReceiver
-    ? { receiver, rootReceiver, effectiveReceiver } : undefined;
-}
-
-function eventUnresolvedReason(
-  resolved: ExpressionResolution,
-): string | undefined {
-  if (resolved.status === 'static') return undefined;
-  return resolved.value !== undefined && resolved.placeholderKeys.length > 0
-    ? 'dynamic_event_name_identifier'
-    : 'dynamic_event_name_unsupported_expression';
-}
-
-function eventConfidence(reason: string | undefined): number {
-  if (!reason) return 0.8;
-  return reason === 'dynamic_event_name_identifier' ? 0.6 : 0.3;
-}
-
-function eventClassificationEvidence(
-  expression: ts.PropertyAccessExpression,
-  receiver: EventReceiver,
-  resolved: ExpressionResolution,
-): Record<string, unknown> {
-  return {
-    receiver: receiver.receiver,
-    rootReceiver: receiver.rootReceiver,
-    classifier: expression.name.text === 'on'
-      ? 'cap_service_event_subscription' : 'cap_service_event_emit',
-    receiverClassification: 'cap_evidence',
-    ...(resolved.status === 'static' ? {} : {
-      eventNameStatus: resolved.status,
-      eventNameSourceKind: resolved.sourceKind,
-      eventNamePlaceholderKeys: resolved.placeholderKeys,
-    }),
-  };
-}
-
-interface EventNameState {
-  eventName: string;
-  resolved: ExpressionResolution;
-  unresolvedReason?: string;
-}
-
-function eventNameState(node: ts.CallExpression): EventNameState | undefined {
-  const expression = node.arguments[0];
-  const resolved = resolveExpression(expression, node, 'operation_path');
-  let eventName = resolved.value;
-  if (eventName === undefined) eventName = resolved.rawExpression;
-  if (eventName === undefined && expression)
-    eventName = expression.getText(node.getSourceFile());
-  if (!eventName) return undefined;
-  return {
-    eventName,
-    resolved,
-    unresolvedReason: eventUnresolvedReason(resolved),
-  };
-}
-
-function excludedEventName(
-  expression: ts.PropertyAccessExpression,
-  receiver: EventReceiver,
-  state: EventNameState,
-): boolean {
-  if (state.resolved.status !== 'static') return false;
-  if (receiver.effectiveReceiver === 'cds'
-    && CDS_LIFECYCLE_EVENTS.has(state.eventName)) return true;
-  return expression.name.text === 'on' && state.eventName === 'error';
-}
-
-function eventCallClassification(
-  node: ts.CallExpression,
-  expression: ts.PropertyAccessExpression,
-  serviceVariables: Set<string>,
-): EventCallClassification | undefined {
-  const receiver = eventReceiver(expression, serviceVariables);
-  if (!receiver) return undefined;
-  const state = eventNameState(node);
-  if (!state || excludedEventName(expression, receiver, state))
-    return undefined;
-  return {
-    fact: {
-      callType: expression.name.text === 'on'
-        ? 'async_subscribe' : 'async_emit',
-      serviceVariableName: receiver.effectiveReceiver,
-      eventNameExpr: state.eventName,
-      confidence: eventConfidence(state.unresolvedReason),
-      unresolvedReason: state.unresolvedReason,
-    },
-    evidence: eventClassificationEvidence(
-      expression, receiver, state.resolved,
-    ),
-  };
-}
-
 type OutboundFactInput = Omit<
   OutboundCallFact, 'sourceFile' | 'sourceLine' | 'confidence'
 > & { confidence?: number };
@@ -208,6 +106,7 @@ interface OutboundCallContext {
   source: ts.SourceFile;
   initializers: Map<string, ts.Expression>;
   serviceVariables: Set<string>;
+  eventAnalysis: EventCallAnalysisContext;
   wrapperSpecs: Map<string, WrapperSpec>;
   add: AddOutboundCall;
 }
@@ -589,11 +488,10 @@ function classifyEventCall(
   const expression = node.expression;
   if (!ts.isPropertyAccessExpression(expression)
     || !['emit', 'publish', 'on'].includes(expression.name.text)) return false;
-  const event = eventCallClassification(
-    node, expression, context.serviceVariables,
-  );
-  if (event) context.add(node, event.fact, event.evidence);
-  return true;
+  const event = analyzeEventCall(node, expression, context.eventAnalysis);
+  if (event.status === 'classified')
+    context.add(node, event.fact, event.evidence);
+  return event.status !== 'unclassified';
 }
 
 function classifyExternalCall(
@@ -661,11 +559,16 @@ function visitOutboundCalls(
 export function classifyOutboundCallsInSource(
   source: ts.SourceFile,
   filePath: string,
+  options: OutboundClassificationOptions = {},
 ): ClassifiedOutboundCall[] {
   const calls: ClassifiedOutboundCall[] = [];
   const sourceFile = normalizePath(filePath);
   const initializers = variableInitializers(source);
   const serviceVariables = collectServiceVariables(source);
+  const eventAnalysis = createEventCallAnalysisContext(
+    source, serviceVariables, options.importedEventNameResolver,
+    options.eventEnvironmentReferenceResolver,
+  );
   const wrapperSpecs = collectWrapperSpecs(source);
   const internalRanges = [...wrapperSpecs.values()].map((spec) => ({
     start: spec.internalStart, end: spec.internalEnd,
@@ -682,7 +585,7 @@ export function classifyOutboundCallsInSource(
     } });
   };
   const context = {
-    source, initializers, serviceVariables, wrapperSpecs, add,
+    source, initializers, serviceVariables, eventAnalysis, wrapperSpecs, add,
   };
   visitOutboundCalls(
     source, internalRanges,

package/src/parsers/outbound-call-parser.ts

@@ -15,6 +15,12 @@ import {
 import { parseImportedWrapperCalls } from './imported-wrapper-parser.js';
 import { parseServiceBindings } from './service-binding-parser.js';
 import type { RepositorySourceContext } from './ts-project.js';
+import {
+  createImportedEventNameResolver,
+} from './event-name-import-resolution.js';
+import {
+  createEventEnvironmentReferenceResolver,
+} from './event-environment-reference.js';
 
 export {
   classifyOutboundCallsInSource,
@@ -77,7 +83,13 @@ export async function parseOutboundCalls(
     repoPath, filePath, source, bindingNames, context,
   );
   const nativeCalls = classified
-    ?? classifyOutboundCallsInSource(source, filePath);
+    ?? classifyOutboundCallsInSource(source, filePath, context ? {
+      importedEventNameResolver: createImportedEventNameResolver(
+        context, source, filePath,
+      ),
+      eventEnvironmentReferenceResolver:
+        createEventEnvironmentReferenceResolver(context, source, filePath),
+    } : undefined);
   return [
     ...nativeCalls.map((call) => call.fact),
     ...importedWrappers,

package/src/parsers/outbound-expression-analysis.ts

@@ -55,7 +55,6 @@ export function queryWarning(expression: string): string {
     return 'query_variable_without_static_initializer';
   return 'dynamic_entity_expression';
 }
-
 export function parserEvidence(
   source: ts.SourceFile,
   node: ts.CallExpression,
@@ -109,7 +108,8 @@ type ExpressionSourceKind =
   | 'string_literal'
   | 'no_substitution_template'
   | 'template_with_substitutions'
-  | 'const_alias'
+  | 'const_alias' | 'const_identifier'
+  | 'enum_member' | 'const_object_property'
   | 'conditional_candidates'
   | 'dynamic_expression';
 

package/src/parsers/stable-local-value.ts

@@ -37,19 +37,38 @@ function directWriteTarget(node: ts.Node): boolean {
     && parent.initializer === use;
 }
 
-type MemberContainer = ts.ObjectLiteralExpression | ts.ClassLikeDeclaration;
-type StableMember = ts.ObjectLiteralElementLike | ts.ClassElement;
+type MemberContainer =
+  | ts.ObjectLiteralExpression
+  | ts.ClassLikeDeclaration
+  | ts.EnumDeclaration;
+type StableMember =
+  | ts.ObjectLiteralElementLike
+  | ts.ClassElement
+  | ts.EnumMember;
+
+function memberInitializer(
+  expression: ts.Expression,
+): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    return memberInitializer(expression.expression);
+  return expression;
+}
 
 function memberContainer(
   declaration: ts.Identifier,
 ): MemberContainer | undefined {
   const parent = declaration.parent;
   if (ts.isClassDeclaration(parent)) return parent;
+  if (ts.isEnumDeclaration(parent)) return parent;
   if (!ts.isVariableDeclaration(parent) || parent.name !== declaration
     || !parent.initializer) return undefined;
-  return ts.isObjectLiteralExpression(parent.initializer)
-    || ts.isClassExpression(parent.initializer)
-    ? parent.initializer
+  const initializer = memberInitializer(parent.initializer);
+  return ts.isObjectLiteralExpression(initializer)
+    || ts.isClassExpression(initializer)
+    ? initializer
     : undefined;
 }
 
@@ -81,10 +100,12 @@ function matchingMember(
 ): StableMember | undefined {
   const members = ts.isObjectLiteralExpression(value)
     ? value.properties
-    : value.members.filter((member) =>
-      ts.canHaveModifiers(member)
-      && ts.getModifiers(member)?.some((modifier) =>
-        modifier.kind === ts.SyntaxKind.StaticKeyword));
+    : ts.isEnumDeclaration(value)
+      ? value.members
+      : value.members.filter((member) =>
+        ts.canHaveModifiers(member)
+        && ts.getModifiers(member)?.some((modifier) =>
+          modifier.kind === ts.SyntaxKind.StaticKeyword));
   const matches = members.filter((member) =>
     'name' in member && member.name && memberName(member.name) === name);
   if (matches.length === 1) return matches[0];

package/src/parsers/string-constant-lookups.ts

@@ -0,0 +1,358 @@
+import ts from 'typescript';
+import { stableLocalValueReference } from './stable-local-value.js';
+import { lexicalIdentifierDeclaration } from './symbol-import-bindings.js';
+
+export type StaticStringConstantKind =
+  | 'const_identifier'
+  | 'enum_member'
+  | 'const_object_property';
+
+export interface StaticStringConstant {
+  key: string;
+  value: string;
+  kind: StaticStringConstantKind;
+  containerName?: string;
+  memberName?: string;
+  sourceFile: string;
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  valueStartOffset: number;
+  valueEndOffset: number;
+  exported: boolean;
+  stable: boolean;
+}
+
+export interface StaticStringRefusal {
+  key: string;
+  kind: StaticStringConstantKind;
+  containerName?: string;
+  memberName?: string;
+  sourceFile: string;
+  declarationStartOffset: number;
+  declarationEndOffset: number;
+  exported: boolean;
+  stable: boolean;
+  reason: 'event_name_constant_member_not_string'
+    | 'event_name_constant_container_mutable';
+}
+
+export interface StringConstantLookups {
+  identifiers: Map<string, StaticStringConstant>;
+  enumMembers: Map<string, StaticStringConstant>;
+  objectProperties: Map<string, StaticStringConstant>;
+  refusedMembers: Map<string, StaticStringRefusal>;
+}
+
+export type StaticStringLookupResult =
+  | { status: 'resolved'; constant: StaticStringConstant }
+  | { status: 'refused'; reason: string }
+  | { status: 'not_found' };
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    return unwrapExpression(expression.expression);
+  return expression;
+}
+
+function stringValue(
+  expression: ts.Expression | undefined,
+): { value: string; node: ts.Expression } | undefined {
+  if (!expression) return undefined;
+  const value = unwrapExpression(expression);
+  return ts.isStringLiteralLike(value)
+    ? { value: value.text, node: value } : undefined;
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name) ? name.text : undefined;
+}
+
+function exportedNames(source: ts.SourceFile): Set<string> {
+  const names = new Set<string>();
+  for (const statement of source.statements) {
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier
+      || !statement.exportClause
+      || !ts.isNamedExports(statement.exportClause)) continue;
+    for (const element of statement.exportClause.elements)
+      names.add(element.propertyName?.text ?? element.name.text);
+  }
+  return names;
+}
+
+function hasExportModifier(node: ts.Node): boolean {
+  return ts.canHaveModifiers(node)
+    && Boolean(ts.getModifiers(node)?.some((modifier) =>
+      modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+
+function staticFact(
+  source: ts.SourceFile,
+  key: string,
+  value: { value: string; node: ts.Expression },
+  declaration: ts.Node,
+  fields: Pick<StaticStringConstant, 'kind' | 'exported' | 'stable'>
+    & Partial<Pick<StaticStringConstant, 'containerName' | 'memberName'>>,
+): StaticStringConstant {
+  return {
+    key,
+    value: value.value,
+    sourceFile: source.fileName,
+    declarationStartOffset: declaration.getStart(source),
+    declarationEndOffset: declaration.getEnd(),
+    valueStartOffset: value.node.getStart(source),
+    valueEndOffset: value.node.getEnd(),
+    ...fields,
+  };
+}
+
+function refusalFact(
+  source: ts.SourceFile,
+  key: string,
+  declaration: ts.Node,
+  fields: Pick<StaticStringRefusal,
+    'kind' | 'exported' | 'stable' | 'reason'>
+    & Partial<Pick<StaticStringRefusal, 'containerName' | 'memberName'>>,
+): StaticStringRefusal {
+  return {
+    key,
+    sourceFile: source.fileName,
+    declarationStartOffset: declaration.getStart(source),
+    declarationEndOffset: declaration.getEnd(),
+    ...fields,
+  };
+}
+
+function collectEnum(
+  source: ts.SourceFile,
+  statement: ts.EnumDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  const stable = stableLocalValueReference(source, statement.name);
+  const exported = hasExportModifier(statement)
+    || exports.has(statement.name.text);
+  for (const member of statement.members) {
+    const memberName = propertyName(member.name);
+    if (!memberName) continue;
+    const key = `${statement.name.text}.${memberName}`;
+    const value = stringValue(member.initializer);
+    if (!stable) lookups.refusedMembers.set(key, refusalFact(
+      source, key, member, {
+        kind: 'enum_member', containerName: statement.name.text,
+        memberName, exported, stable,
+        reason: 'event_name_constant_container_mutable',
+      },
+    ));
+    else if (!value) lookups.refusedMembers.set(key, refusalFact(
+      source, key, member, {
+        kind: 'enum_member', containerName: statement.name.text,
+        memberName, exported, stable,
+        reason: 'event_name_constant_member_not_string',
+      },
+    ));
+    else lookups.enumMembers.set(key, staticFact(
+      source, key, value, member, {
+        kind: 'enum_member',
+        containerName: statement.name.text,
+        memberName,
+        exported,
+        stable,
+      },
+    ));
+  }
+}
+
+function objectLiteral(
+  expression: ts.Expression,
+): ts.ObjectLiteralExpression | undefined {
+  const value = unwrapExpression(expression);
+  return ts.isObjectLiteralExpression(value) ? value : undefined;
+}
+
+function collectObject(
+  source: ts.SourceFile,
+  statement: ts.VariableStatement,
+  declaration: ts.VariableDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+  const object = objectLiteral(declaration.initializer);
+  if (!object) return;
+  const stable = stableLocalValueReference(source, declaration.name);
+  const exported = hasExportModifier(statement)
+    || exports.has(declaration.name.text);
+  for (const property of object.properties) {
+    if (!ts.isPropertyAssignment(property)) continue;
+    const memberName = propertyName(property.name);
+    if (!memberName) continue;
+    const key = `${declaration.name.text}.${memberName}`;
+    const value = stringValue(property.initializer);
+    if (!stable) lookups.refusedMembers.set(key, refusalFact(
+      source, key, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text, memberName,
+        exported, stable,
+        reason: 'event_name_constant_container_mutable',
+      },
+    ));
+    else if (!value) lookups.refusedMembers.set(key, refusalFact(
+      source, key, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text, memberName,
+        exported, stable,
+        reason: 'event_name_constant_member_not_string',
+      },
+    ));
+    else lookups.objectProperties.set(key, staticFact(
+      source, key, value, property, {
+        kind: 'const_object_property',
+        containerName: declaration.name.text,
+        memberName,
+        exported,
+        stable,
+      },
+    ));
+  }
+}
+
+function collectIdentifier(
+  source: ts.SourceFile,
+  statement: ts.VariableStatement,
+  declaration: ts.VariableDeclaration,
+  exports: Set<string>,
+  lookups: StringConstantLookups,
+): void {
+  if (!ts.isIdentifier(declaration.name) || !declaration.initializer) return;
+  const value = stringValue(declaration.initializer);
+  if (!value) return;
+  const key = declaration.name.text;
+  lookups.identifiers.set(key, staticFact(
+    source, key, value, declaration, {
+      kind: 'const_identifier',
+      exported: hasExportModifier(statement) || exports.has(key),
+      stable: true,
+    },
+  ));
+}
+
+export function collectStringConstantLookups(
+  source: ts.SourceFile,
+): StringConstantLookups {
+  const lookups: StringConstantLookups = {
+    identifiers: new Map(),
+    enumMembers: new Map(),
+    objectProperties: new Map(),
+    refusedMembers: new Map(),
+  };
+  const exports = exportedNames(source);
+  for (const statement of source.statements) {
+    if (ts.isEnumDeclaration(statement))
+      collectEnum(source, statement, exports, lookups);
+    if (!ts.isVariableStatement(statement)
+      || (statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      collectIdentifier(source, statement, declaration, exports, lookups);
+      collectObject(source, statement, declaration, exports, lookups);
+    }
+  }
+  return lookups;
+}
+
+export function resolveStringConstant(
+  expression: ts.Expression,
+  lookups: StringConstantLookups,
+): StaticStringLookupResult {
+  const value = unwrapExpression(expression);
+  if (ts.isIdentifier(value)) {
+    const constant = lookups.identifiers.get(value.text);
+    return constant && constantReferenceMatches(value, constant)
+      ? { status: 'resolved', constant } : { status: 'not_found' };
+  }
+  if (ts.isElementAccessExpression(value)
+    && ts.isIdentifier(value.expression)) {
+    const prefix = `${value.expression.text}.`;
+    const known = [
+      ...lookups.enumMembers.keys(),
+      ...lookups.objectProperties.keys(),
+      ...lookups.refusedMembers.keys(),
+    ].some((key) => key.startsWith(prefix));
+    return known && constantContainerMatches(
+      value.expression, lookups, prefix,
+    ) ? {
+      status: 'refused',
+      reason: 'event_name_constant_container_ambiguous',
+    } : { status: 'not_found' };
+  }
+  if (!ts.isPropertyAccessExpression(value)
+    || value.questionDotToken || !ts.isIdentifier(value.expression))
+    return { status: 'not_found' };
+  const key = `${value.expression.text}.${value.name.text}`;
+  const constant = lookups.enumMembers.get(key)
+    ?? lookups.objectProperties.get(key);
+  if (constant && constantReferenceMatches(value.expression, constant))
+    return { status: 'resolved', constant };
+  const reason = lookups.refusedMembers.get(key);
+  return reason && refusalReferenceMatches(value.expression, reason)
+    ? { status: 'refused', reason: reason.reason }
+    : constant || reason ? {
+        status: 'refused',
+        reason: 'event_name_constant_container_ambiguous',
+      } : { status: 'not_found' };
+}
+
+function declarationContains(
+  identifier: ts.Identifier,
+  startOffset: number,
+  endOffset: number,
+): boolean {
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration) return false;
+  const owner = declaration.parent;
+  return owner.getSourceFile() === identifier.getSourceFile()
+    && owner.getStart(identifier.getSourceFile()) <= startOffset
+    && owner.getEnd() >= endOffset;
+}
+
+function constantReferenceMatches(
+  identifier: ts.Identifier,
+  constant: StaticStringConstant,
+): boolean {
+  return declarationContains(
+    identifier,
+    constant.declarationStartOffset,
+    constant.declarationEndOffset,
+  );
+}
+
+function refusalReferenceMatches(
+  identifier: ts.Identifier,
+  refusal: StaticStringRefusal,
+): boolean {
+  return declarationContains(
+    identifier,
+    refusal.declarationStartOffset,
+    refusal.declarationEndOffset,
+  );
+}
+
+function constantContainerMatches(
+  identifier: ts.Identifier,
+  lookups: StringConstantLookups,
+  prefix: string,
+): boolean {
+  const constants = [
+    ...lookups.enumMembers.values(),
+    ...lookups.objectProperties.values(),
+  ].filter((item) => item.key.startsWith(prefix));
+  const refusals = [...lookups.refusedMembers.values()]
+    .filter((item) => item.key.startsWith(prefix));
+  return [...constants, ...refusals].some((item) =>
+    declarationContains(
+      identifier, item.declarationStartOffset, item.declarationEndOffset,
+    ));
+}