@saptools/service-flow 0.1.69 → 0.1.72

package/src/parsers/{023-outbound-call-classifier.ts → outbound-call-classifier.ts}

@@ -4,18 +4,16 @@ import { classifyODataPathIntent } from '../linker/odata-path-normalizer.js';
 import type { OutboundCallFact } from '../types.js';
 import { normalizePath, stripQuotes } from '../utils/path-utils.js';
 import { summarizeExpression } from '../utils/redaction.js';
-import { directQueryBuilderStatement } from './000-direct-query-execution.js';
+import { directQueryBuilderStatement } from './direct-query-execution.js';
 import {
   expressionName,
   queryEntityFromAst,
   variableInitializers,
-} from './001-query-entity-resolution.js';
+} from './query-entity-resolution.js';
 import {
-  CDS_LIFECYCLE_EVENTS,
   calledWrapperNames,
   collectServiceVariables,
   externalHttpEvidence,
-  isSupportedEventReceiver,
   legacyPathCandidates,
   lineOf,
   literalPathSource,
@@ -34,7 +32,18 @@ import {
   wrapperSpec,
   type ExpressionResolution,
   type WrapperSpec,
-} from './022-outbound-expression-analysis.js';
+} 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

@@ -6,15 +6,21 @@ import { normalizePath } from '../utils/path-utils.js';
 import {
   classifyOutboundCallsInSource,
   type ClassifiedOutboundCall,
-} from './023-outbound-call-classifier.js';
+} from './outbound-call-classifier.js';
 import {
   lineOf,
   literalText,
   parserEvidence,
-} from './022-outbound-expression-analysis.js';
+} from './outbound-expression-analysis.js';
 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/{022-outbound-expression-analysis.ts → outbound-expression-analysis.ts}

@@ -3,12 +3,12 @@ import {
   chainIncludesForUpdate,
   queryBuilderRoot,
   type DirectQueryBuilderStatement,
-} from './000-direct-query-execution.js';
+} from './direct-query-execution.js';
 import {
   expressionName,
   maxAliasDepth,
   resolveBinding,
-} from './001-query-entity-resolution.js';
+} from './query-entity-resolution.js';
 import type { OperationPathAnalysis } from './operation-path-analysis.js';
 import { stripQuotes } from '../utils/path-utils.js';
 export function lineOf(text: string, index: number): number {
@@ -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/{018-package-commonjs-syntax.ts → package-commonjs-syntax.ts}

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import {
   lexicalIdentifierDeclarations,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 
 interface AccessPath {
   root: ts.Identifier;

package/src/parsers/{012-package-fact-contract.ts → package-fact-contract.ts}

@@ -1,20 +1,20 @@
 import {
   PACKAGE_PUBLIC_SURFACE_RECORD_CAP,
   PACKAGE_PUBLIC_SURFACE_SCHEMA,
-} from './003-package-public-surface.js';
+} from './package-public-surface.js';
 import type {
   ExecutableBodyEligibility,
   PackagePublicEntry,
   PackagePublicScope,
   PackagePublicSurfaceFact,
   PublicSurfaceTarget,
-} from './003-package-public-surface.js';
+} from './package-public-surface.js';
 import {
   packageModuleRequest,
   type SymbolImportBindingKind,
   type SymbolImportReference,
   type SymbolImportReferenceShape,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 
 const bindingKinds = new Set<SymbolImportBindingKind>([
   'esm_named', 'esm_default', 'esm_namespace',

package/src/parsers/{010-package-public-surface-analysis.ts → package-public-surface-analysis.ts}

@@ -4,7 +4,7 @@ import {
   PACKAGE_PUBLIC_SURFACE_RECORD_CAP,
   PACKAGE_PUBLIC_SURFACE_SCHEMA,
   resolveModule,
-} from './003-package-public-surface.js';
+} from './package-public-surface.js';
 import type {
   ModuleInfo,
   ModuleResolution,
@@ -16,7 +16,7 @@ import type {
   PackageSourceModule,
   ResolvedExport,
   SymbolPublicSurfaceEvidence,
-} from './003-package-public-surface.js';
+} from './package-public-surface.js';
 import type { PackageEntrypointManifest } from './package-json-parser.js';
 
 interface EntryResolution {

package/src/parsers/{003-package-public-surface.ts → package-public-surface.ts}

@@ -4,8 +4,8 @@ import {
   hasNestedCommonJsMutation,
   isUnshadowedCommonJsExportExpression,
   unsupportedCommonJsMutation,
-} from './018-package-commonjs-syntax.js';
-import { stableLocalValueReference } from './020-stable-local-value.js';
+} from './package-commonjs-syntax.js';
+import { stableLocalValueReference } from './stable-local-value.js';
 
 export const PACKAGE_PUBLIC_SURFACE_SCHEMA =
   'service-flow/package-public-surface@1';
@@ -658,4 +658,4 @@ export function moduleInfoMap(
 }
 
 export { analyzePackagePublicSurface } from
-  './010-package-public-surface-analysis.js';
+  './package-public-surface-analysis.js';

package/src/parsers/{008-package-surface-publication.ts → package-surface-publication.ts}

@@ -8,7 +8,7 @@ import {
   analyzePackagePublicSurface,
   type PackagePublicSurfaceAnalysis,
   type SymbolPublicSurfaceEvidence,
-} from './003-package-public-surface.js';
+} from './package-public-surface.js';
 import type { RepositorySourceContext } from './ts-project.js';
 
 function symbolIdentity(

package/src/parsers/{001-query-entity-resolution.ts → query-entity-resolution.ts}

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { isCapQueryBuilderRootName } from './000-direct-query-execution.js';
+import { isCapQueryBuilderRootName } from './direct-query-execution.js';
 
 export interface BindingResolution {
   declaration?: ts.VariableDeclaration | ts.ParameterDeclaration;

package/src/parsers/{015-service-binding-collector.ts → service-binding-collector.ts}

@@ -15,8 +15,8 @@ import {
   createBindingLexicalIndex,
   type BindingLexicalIndex,
   type BindingSiteCandidate,
-} from './011-binding-lexical-scope.js';
-import { selectVisibleBinding } from './021-binding-visibility.js';
+} from './binding-lexical-scope.js';
+import { selectVisibleBinding } from './binding-visibility.js';
 import {
   arrayAssignmentName,
   arrayBindingName,
@@ -24,7 +24,7 @@ import {
   collectReturnedObjectBindings,
   directConnectFactFromFunctionLike,
   functionLikeInitializer,
-} from './014-service-binding-helper-flow.js';
+} from './service-binding-helper-flow.js';
 
 type ResolvedHelper = { helper: HelperBinding; imp?: ImportBinding };
 type BindingEvent = {

package/src/parsers/{014-service-binding-helper-flow.ts → service-binding-helper-flow.ts}

@@ -11,8 +11,8 @@ import {
   type BindingLexicalIndex,
   type BindingSiteCandidate,
   type VisibleBinding,
-} from './011-binding-lexical-scope.js';
-import { selectVisibleBinding } from './021-binding-visibility.js';
+} from './binding-lexical-scope.js';
+import { selectVisibleBinding } from './binding-visibility.js';
 
 export type LocalBindingFact = Omit<
   HelperBinding,

package/src/parsers/service-binding-parser-helpers.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import ts from 'typescript';
 import { normalizePath } from '../utils/path-utils.js';
-import { extractPlaceholderKeys } from '../utils/001-placeholders.js';
+import { extractPlaceholderKeys } from '../utils/placeholders.js';
 import type { RepositorySourceContext } from './ts-project.js';
 
 export interface HelperBinding {

package/src/parsers/service-binding-parser.ts

@@ -15,8 +15,8 @@ import {
   directConnectFactFromFunctionLike,
   functionLikeInitializer,
   type LocalBindingFact,
-} from './014-service-binding-helper-flow.js';
-import { collectServiceBindings } from './015-service-binding-collector.js';
+} from './service-binding-helper-flow.js';
+import { collectServiceBindings } from './service-binding-collector.js';
 import type { RepositorySourceContext } from './ts-project.js';
 
 interface LocalHelperFact extends LocalBindingFact {

package/src/parsers/{007-source-fact-reconciliation.ts → source-fact-reconciliation.ts}

@@ -8,9 +8,9 @@ import type {
 import {
   executableSymbolCandidates,
   selectCallOwner,
-} from './004-fact-identity.js';
-import { reconcileEventSubscriptions } from './005-event-subscription-facts.js';
-import { reconcileBindingAndCallIdentity } from './006-binding-identity.js';
+} from './fact-identity.js';
+import { reconcileEventSubscriptions } from './event-subscription-facts.js';
+import { reconcileBindingAndCallIdentity } from './binding-identity.js';
 import type { ClassifiedOutboundCall } from './outbound-call-parser.js';
 
 export interface ReconciledSourceFacts {

package/src/parsers/{020-stable-local-value.ts → stable-local-value.ts}

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 import {
   identifierMatchesDeclaration,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 import {
   isUnshadowedCommonJsExportExpression,
-} from './018-package-commonjs-syntax.js';
+} from './package-commonjs-syntax.js';
 
 function transparentUse(node: ts.Node): ts.Node {
   const parent = node.parent;
@@ -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];