@saptools/service-flow 0.1.69 → 0.1.72

package/src/parsers/event-receiver-analysis.ts

@@ -0,0 +1,404 @@
+import ts from 'typescript';
+import type { LexicalScopeFact } from '../types.js';
+import {
+  createBindingLexicalIndex,
+  declarationAt,
+  lexicalScopeChain,
+  sameScope,
+  type BindingLexicalIndex,
+  type BindingLexicalSite,
+} from './binding-lexical-scope.js';
+import {
+  collectSymbolImportBindings,
+  lexicalIdentifierDeclaration,
+  type SymbolImportBinding,
+} from './symbol-import-bindings.js';
+import { stableLocalValueReference } from './stable-local-value.js';
+
+export type EventReceiverUnresolvedReason =
+  | 'event_receiver_unproven_binding'
+  | 'event_receiver_unproven_propagation'
+  | 'event_receiver_not_cap_client';
+
+export interface EventReceiverEvidenceSite {
+  startOffset: number;
+  endOffset: number;
+  flow: BindingLexicalSite['flow'];
+  connect: boolean;
+}
+
+export interface EventReceiverProof {
+  effectiveReceiver: string;
+  receiver?: string;
+  rootReceiver?: string;
+  receiverClassification: 'cap_evidence' | 'name_fallback' | 'unproven';
+  receiverProof: string;
+  unresolvedReason?: EventReceiverUnresolvedReason;
+  consideredBindingSites: EventReceiverEvidenceSite[];
+}
+
+export interface EventReceiverIndex {
+  source: ts.SourceFile;
+  lexical: BindingLexicalIndex;
+  imports: SymbolImportBinding[];
+  compatibilityNames: Set<string>;
+}
+
+const eventReceiverNames = new Set([
+  'cds', 'srv', 'service', 'serviceClient', 'messaging', 'messageClient',
+  'eventClient',
+]);
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  if (ts.isAwaitExpression(expression)
+    || ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression))
+    return unwrapExpression(expression.expression);
+  return expression;
+}
+
+function capConnectCall(
+  expression: ts.Expression,
+): ts.CallExpression | undefined {
+  const value = unwrapExpression(expression);
+  if (!ts.isCallExpression(value)
+    || !ts.isPropertyAccessExpression(value.expression)) return undefined;
+  const callee = value.expression;
+  if (callee.name.text === 'catch'
+    && ts.isCallExpression(callee.expression))
+    return capConnectCall(callee.expression);
+  if (!['to', 'messaging'].includes(callee.name.text)
+    || !ts.isPropertyAccessExpression(callee.expression)
+    || callee.expression.name.text !== 'connect') return undefined;
+  return ts.isIdentifier(callee.expression.expression) ? value : undefined;
+}
+
+function importedCdsRoot(
+  call: ts.CallExpression,
+  bindings: readonly SymbolImportBinding[],
+): boolean {
+  const callee = call.expression;
+  if (!ts.isPropertyAccessExpression(callee)
+    || !ts.isPropertyAccessExpression(callee.expression)
+    || !ts.isIdentifier(callee.expression.expression)) return false;
+  const root = callee.expression.expression;
+  const declaration = lexicalIdentifierDeclaration(root);
+  if (!declaration) return root.text === 'cds';
+  const start = declaration.getStart(root.getSourceFile());
+  const end = declaration.getEnd();
+  const matches = bindings.filter((binding) =>
+    binding.localName === root.text
+    && binding.bindingSiteStartOffset === start
+    && binding.bindingSiteEndOffset === end);
+  return matches.length === 1
+    && matches[0]?.rawModuleSpecifier === '@sap/cds';
+}
+
+function importedCdsIdentifier(
+  identifier: ts.Identifier,
+  index: EventReceiverIndex,
+): boolean {
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration) return false;
+  const start = declaration.getStart(index.source);
+  const end = declaration.getEnd();
+  const matches = index.imports.filter((binding) =>
+    binding.localName === identifier.text
+    && binding.bindingSiteStartOffset === start
+    && binding.bindingSiteEndOffset === end);
+  return matches.length === 1
+    && matches[0]?.rawModuleSpecifier === '@sap/cds';
+}
+
+function isCapConnect(
+  expression: ts.Expression | undefined,
+  bindings: readonly SymbolImportBinding[],
+): boolean {
+  if (!expression) return false;
+  const call = capConnectCall(expression);
+  return Boolean(call && importedCdsRoot(call, bindings));
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name)
+    || ts.isNumericLiteral(name) ? name.text : undefined;
+}
+
+function objectSource(
+  expression: ts.Expression | undefined,
+): ts.ObjectLiteralExpression | undefined {
+  if (!expression) return undefined;
+  const value = unwrapExpression(expression);
+  if (ts.isObjectLiteralExpression(value)) return value;
+  if (!ts.isIdentifier(value)) return undefined;
+  const binding = resolveLocalInitializer(value);
+  return binding ? objectSource(binding) : undefined;
+}
+
+function resolveLocalInitializer(
+  identifier: ts.Identifier,
+): ts.Expression | undefined {
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration || !ts.isVariableDeclaration(declaration.parent)
+    || !stableLocalValueReference(identifier.getSourceFile(), declaration))
+    return undefined;
+  return declaration.parent.initializer;
+}
+
+function objectMember(
+  object: ts.ObjectLiteralExpression,
+  name: string,
+): ts.Expression | undefined {
+  for (const property of object.properties) {
+    if (ts.isPropertyAssignment(property)
+      && propertyName(property.name) === name) return property.initializer;
+    if (ts.isShorthandPropertyAssignment(property)
+      && property.name.text === name) return property.name;
+  }
+  return undefined;
+}
+
+function declarationBindingKey(
+  declaration: ts.VariableDeclaration,
+  variableName: string,
+): string | undefined {
+  if (!ts.isObjectBindingPattern(declaration.name)) return undefined;
+  const match = declaration.name.elements.find((element) =>
+    ts.isIdentifier(element.name) && element.name.text === variableName);
+  if (!match) return undefined;
+  return match.propertyName
+    ? propertyName(match.propertyName) : variableName;
+}
+
+function assignmentBindingKey(
+  node: ts.BinaryExpression,
+  variableName: string,
+): string | undefined {
+  const left = unwrapExpression(node.left);
+  if (!ts.isObjectLiteralExpression(left)) return undefined;
+  for (const property of left.properties) {
+    if (ts.isShorthandPropertyAssignment(property)
+      && property.name.text === variableName) return variableName;
+    if (ts.isPropertyAssignment(property)
+      && ts.isIdentifier(property.initializer)
+      && property.initializer.text === variableName)
+      return propertyName(property.name);
+  }
+  return undefined;
+}
+
+function siteExpression(
+  site: BindingLexicalSite,
+  variableName: string,
+): ts.Expression | undefined {
+  if (ts.isVariableDeclaration(site.node)) {
+    if (!ts.isIdentifier(site.node.name)) {
+      const key = declarationBindingKey(site.node, variableName);
+      const object = objectSource(site.node.initializer);
+      return key && object ? objectMember(object, key) : undefined;
+    }
+    if (site.node.name.text !== variableName) return undefined;
+    return site.node.initializer;
+  }
+  if (!ts.isBinaryExpression(site.node)
+    || site.node.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+    return undefined;
+  const key = assignmentBindingKey(site.node, variableName);
+  const object = objectSource(site.node.right);
+  return key && object ? objectMember(object, key) : site.node.right;
+}
+
+function sameExecutionScope(
+  left: LexicalScopeFact,
+  right: LexicalScopeFact,
+): boolean {
+  return sameScope(left, right);
+}
+
+function unsupportedBranch(node: ts.Node): boolean {
+  let current: ts.Node | undefined = node.parent;
+  while (current && !ts.isSourceFile(current) && !ts.isFunctionLike(current)) {
+    if (ts.isIfStatement(current) || ts.isConditionalExpression(current)
+      || ts.isSwitchStatement(current)
+      || ts.isIterationStatement(current, false)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+function reachingSites(
+  index: EventReceiverIndex,
+  declaration: BindingLexicalSite,
+  useStart: number,
+): BindingLexicalSite[] {
+  return index.lexical.sites.filter((site) =>
+    site.declarationKey === declaration.declarationKey
+    && site.startOffset < useStart
+    && site.flow !== 'shadow'
+    && sameExecutionScope(site.executionScope, declaration.executionScope));
+}
+
+function evidenceSites(
+  sites: readonly BindingLexicalSite[],
+  variableName: string,
+  bindings: readonly SymbolImportBinding[],
+): EventReceiverEvidenceSite[] {
+  return sites.slice(0, 8).map((site) => ({
+    startOffset: site.startOffset,
+    endOffset: site.endOffset,
+    flow: site.flow,
+    connect: isCapConnect(siteExpression(site, variableName), bindings),
+  }));
+}
+
+function lexicalProof(
+  identifier: ts.Identifier,
+  use: ts.Node,
+  index: EventReceiverIndex,
+): Omit<EventReceiverProof, 'effectiveReceiver' | 'receiver'
+  | 'rootReceiver'> | undefined {
+  const useStart = use.getStart(index.source);
+  const selected = declarationAt(
+    index.lexical.sites, identifier.text, useStart,
+    lexicalScopeChain(use, index.source),
+  );
+  const declaration = selected.site;
+  if (!declaration || selected.after || selected.ambiguous) return undefined;
+  if (declaration.declarationKind === 'parameter')
+    return unproven('event_receiver_unproven_propagation', 'parameter_flow');
+  const sites = reachingSites(index, declaration, useStart);
+  const expressions = sites.flatMap((site) => {
+    const value = siteExpression(site, identifier.text);
+    return value ? [value] : [];
+  });
+  const considered = evidenceSites(sites, identifier.text, index.imports);
+  if (sites.some((site) => unsupportedBranch(site.node)))
+    return unproven(
+      'event_receiver_unproven_binding', 'branch_dependent_assignment',
+      considered,
+    );
+  if (expressions.length > 0
+    && expressions.every((value) => isCapConnect(value, index.imports)))
+    return {
+      receiverClassification: 'cap_evidence',
+      receiverProof: 'lexical_connect_assignment',
+      consideredBindingSites: considered,
+    };
+  if (expressions.some(Boolean)
+    && expressions.every((value) => !isCapConnect(value, index.imports)))
+    return unproven(
+      'event_receiver_not_cap_client', 'non_connect_binding', considered,
+    );
+  return unproven(
+    'event_receiver_unproven_binding', 'mixed_or_missing_assignment',
+    considered,
+  );
+}
+
+function unproven(
+  reason: EventReceiverUnresolvedReason,
+  proof: string,
+  consideredBindingSites: EventReceiverEvidenceSite[] = [],
+): Omit<EventReceiverProof, 'effectiveReceiver' | 'receiver'
+  | 'rootReceiver'> {
+  return {
+    receiverClassification: 'unproven',
+    receiverProof: proof,
+    unresolvedReason: reason,
+    consideredBindingSites,
+  };
+}
+
+function compatibilityFallback(
+  name: string,
+  index: EventReceiverIndex,
+): Omit<EventReceiverProof, 'effectiveReceiver' | 'receiver'
+  | 'rootReceiver'> | undefined {
+  return eventReceiverNames.has(name) || index.compatibilityNames.has(name)
+    ? {
+        receiverClassification: 'name_fallback',
+        receiverProof: 'compatibility_name_fallback',
+        consideredBindingSites: [],
+      }
+    : undefined;
+}
+
+function identifierProof(
+  identifier: ts.Identifier,
+  use: ts.Node,
+  index: EventReceiverIndex,
+): Omit<EventReceiverProof, 'effectiveReceiver' | 'receiver'
+  | 'rootReceiver'> {
+  if (importedCdsIdentifier(identifier, index)) return {
+    receiverClassification: 'cap_evidence',
+    receiverProof: 'imported_cds_receiver',
+    consideredBindingSites: [],
+  };
+  if (identifier.text === 'cds'
+    && !lexicalIdentifierDeclaration(identifier)) return {
+    receiverClassification: 'cap_evidence',
+    receiverProof: 'global_cds_receiver',
+    consideredBindingSites: [],
+  };
+  const proven = lexicalProof(identifier, use, index);
+  if (proven?.receiverClassification === 'cap_evidence') return proven;
+  return compatibilityFallback(identifier.text, index)
+    ?? proven
+    ?? unproven('event_receiver_unproven_binding', 'binding_not_found');
+}
+
+function rootIdentifier(
+  expression: ts.Expression,
+): ts.Identifier | undefined {
+  if (ts.isIdentifier(expression)) return expression;
+  if (ts.isPropertyAccessExpression(expression)
+    || ts.isElementAccessExpression(expression))
+    return rootIdentifier(expression.expression);
+  if (ts.isCallExpression(expression))
+    return rootIdentifier(expression.expression);
+  return undefined;
+}
+
+export function createEventReceiverIndex(
+  source: ts.SourceFile,
+  compatibilityNames: Set<string>,
+): EventReceiverIndex {
+  return {
+    source,
+    lexical: createBindingLexicalIndex(source),
+    imports: collectSymbolImportBindings(source),
+    compatibilityNames,
+  };
+}
+
+export function proveEventReceiver(
+  expression: ts.Expression,
+  use: ts.Node,
+  index: EventReceiverIndex,
+): EventReceiverProof {
+  const receiver = expression.getText(index.source);
+  if (ts.isIdentifier(expression)) {
+    const proof = identifierProof(expression, use, index);
+    return {
+      ...proof, receiver, rootReceiver: expression.text,
+      effectiveReceiver: expression.text,
+    };
+  }
+  const root = rootIdentifier(expression);
+  const rootProof = root ? identifierProof(root, use, index) : undefined;
+  const nonCap = rootProof?.unresolvedReason === 'event_receiver_not_cap_client';
+  const proof = nonCap
+    ? unproven('event_receiver_not_cap_client', 'property_non_cap_root')
+    : unproven(
+        'event_receiver_unproven_propagation', 'property_receiver_propagation',
+      );
+  return {
+    ...proof,
+    receiver,
+    rootReceiver: root?.text,
+    effectiveReceiver: receiver,
+  };
+}

package/src/parsers/{005-event-subscription-facts.ts → event-subscription-facts.ts}

@@ -9,12 +9,15 @@ import {
   symbolImportReference,
   type SymbolImportBinding,
   type SymbolImportReference,
-} from './002-symbol-import-bindings.js';
+} from './symbol-import-bindings.js';
 import type { ClassifiedOutboundCall } from './outbound-call-parser.js';
 import {
   localSymbolTarget,
   type LocalSymbolTargetIdentity,
-} from './016-local-symbol-reference.js';
+} from './local-symbol-reference.js';
+import {
+  eventLoopRegistrationEvidence,
+} from './event-loop-registration.js';
 
 interface HandlerTarget {
   calleeExpression: string;
@@ -235,6 +238,7 @@ function enrichSubscription(
   );
   const evidence = {
     ...(classified.fact.evidence ?? {}),
+    ...eventLoopRegistrationEvidence(classified.node, source),
     handlerReferenceStatus: classification.status,
     ...(classification.reason
       ? { handlerReferenceReason: classification.reason }

package/src/parsers/generated-constants-parser.ts

@@ -1,23 +1,89 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import type { GeneratedConstantFact } from '../types.js';
-import { normalizePath, stripQuotes } from '../utils/path-utils.js';
-function lineOf(text: string, idx: number): number {
-  return text.slice(0, idx).split('\n').length;
+import { normalizePath } from '../utils/path-utils.js';
+import {
+  collectStringConstantLookups,
+  type StaticStringConstant,
+  type StaticStringRefusal,
+} from './string-constant-lookups.js';
+import { createSourceFile } from './ts-project.js';
+
+function sourceLine(
+  source: ReturnType<typeof createSourceFile>,
+  offset: number,
+): number {
+  return source.getLineAndCharacterOfPosition(offset).line + 1;
 }
+
+function generatedFact(
+  source: ReturnType<typeof createSourceFile>,
+  filePath: string,
+  constant: StaticStringConstant,
+): GeneratedConstantFact {
+  return {
+    name: constant.key,
+    value: constant.value,
+    sourceFile: normalizePath(filePath),
+    sourceLine: sourceLine(source, constant.declarationStartOffset),
+    containerName: constant.containerName,
+    memberName: constant.memberName,
+    constantKind: constant.kind,
+    exported: constant.exported,
+    stable: constant.stable,
+    resolutionStatus: 'resolved',
+    declarationStartOffset: constant.declarationStartOffset,
+    declarationEndOffset: constant.declarationEndOffset,
+    valueStartOffset: constant.valueStartOffset,
+    valueEndOffset: constant.valueEndOffset,
+  };
+}
+
+function refusedFact(
+  source: ReturnType<typeof createSourceFile>,
+  filePath: string,
+  refusal: StaticStringRefusal,
+): GeneratedConstantFact {
+  return {
+    name: refusal.key,
+    sourceFile: normalizePath(filePath),
+    sourceLine: sourceLine(source, refusal.declarationStartOffset),
+    containerName: refusal.containerName,
+    memberName: refusal.memberName,
+    constantKind: refusal.kind,
+    exported: refusal.exported,
+    stable: refusal.stable,
+    resolutionStatus: 'refused',
+    unresolvedReason: refusal.reason,
+    declarationStartOffset: refusal.declarationStartOffset,
+    declarationEndOffset: refusal.declarationEndOffset,
+    valueStartOffset: refusal.declarationStartOffset,
+    valueEndOffset: refusal.declarationEndOffset,
+  };
+}
+
+export function generatedConstantFacts(
+  source: ReturnType<typeof createSourceFile>,
+  filePath: string,
+): GeneratedConstantFact[] {
+  const lookups = collectStringConstantLookups(source);
+  const constants = [
+    ...lookups.identifiers.values(),
+    ...lookups.enumMembers.values(),
+    ...lookups.objectProperties.values(),
+  ];
+  return [
+    ...constants.map((constant) =>
+      generatedFact(source, filePath, constant)),
+    ...[...lookups.refusedMembers.values()].map((refusal) =>
+      refusedFact(source, filePath, refusal)),
+  ];
+}
+
 export async function parseGeneratedConstants(
   repoPath: string,
-  filePath: string
+  filePath: string,
 ): Promise<GeneratedConstantFact[]> {
   const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
-  return [
-    ...text.matchAll(
-      /(?:export\s+)?(?:const|static\s+readonly)\s+(\w+)\s*=\s*(['"])([^'"]+)\2/g
-    )
-  ].map((m) => ({
-    name: m[1] ?? 'constant',
-    value: stripQuotes(m[3] ?? ''),
-    sourceFile: normalizePath(filePath),
-    sourceLine: lineOf(text, m.index ?? 0)
-  }));
+  return generatedConstantFacts(createSourceFile(filePath, text), filePath);
 }

package/src/parsers/{016-local-symbol-reference.ts → local-symbol-reference.ts}

@@ -3,8 +3,8 @@ import type { ExecutableSymbolFact } from '../types.js';
 import {
   lexicalIdentifierDeclaration,
   lexicalIdentifierDeclarations,
-} from './002-symbol-import-bindings.js';
-import { stableLocalValueReference } from './020-stable-local-value.js';
+} from './symbol-import-bindings.js';
+import { stableLocalValueReference } from './stable-local-value.js';
 
 export interface LocalSymbolTargetIdentity {
   sourceFile: string;

package/src/parsers/operation-path-analysis.ts

@@ -3,7 +3,7 @@ import {
   classifyODataPathIntent,
   normalizeODataOperationInvocationPath,
 } from '../linker/odata-path-normalizer.js';
-import { analyzeODataPathStructure } from '../linker/005-odata-path-structure.js';
+import { analyzeODataPathStructure } from '../linker/odata-path-structure.js';
 
 export type OperationPathStatus = 'static' | 'ambiguous' | 'dynamic' | 'unknown';