@saptools/service-flow 0.1.67 → 0.1.68

package/src/parsers/019-binding-assignment-targets.ts

@@ -0,0 +1,76 @@
+import ts from 'typescript';
+
+export interface BindingAssignmentEntry {
+  variableName: string;
+  arrayIndex?: number;
+  unsupported?: boolean;
+}
+
+function unsupported(
+  entries: readonly BindingAssignmentEntry[],
+): BindingAssignmentEntry[] {
+  return entries.map((entry) => ({
+    ...entry,
+    arrayIndex: undefined,
+    unsupported: true,
+  }));
+}
+
+function objectEntries(
+  property: ts.ObjectLiteralElementLike,
+): BindingAssignmentEntry[] {
+  if (ts.isShorthandPropertyAssignment(property))
+    return [{ variableName: property.name.text }];
+  if (ts.isSpreadAssignment(property))
+    return unsupported(bindingAssignmentEntries(property.expression));
+  if (!ts.isPropertyAssignment(property)) return [];
+  if (ts.isIdentifier(property.initializer))
+    return [{ variableName: property.initializer.text }];
+  return unsupported(bindingAssignmentEntries(property.initializer));
+}
+
+function arrayEntries(
+  element: ts.Expression | ts.OmittedExpression,
+  arrayIndex: number,
+): BindingAssignmentEntry[] {
+  if (ts.isOmittedExpression(element)) return [];
+  if (ts.isIdentifier(element))
+    return [{ variableName: element.text, arrayIndex }];
+  return unsupported(bindingAssignmentEntries(element));
+}
+
+function assignmentTarget(
+  expression: ts.Expression,
+): { expression: ts.Expression; unsupported: boolean } {
+  if (ts.isParenthesizedExpression(expression))
+    return assignmentTarget(expression.expression);
+  if (ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression)) {
+    const target = assignmentTarget(expression.expression);
+    return { expression: target.expression, unsupported: true };
+  }
+  if (ts.isBinaryExpression(expression)
+    && expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+    const target = assignmentTarget(expression.left);
+    return { expression: target.expression, unsupported: true };
+  }
+  return { expression, unsupported: false };
+}
+
+export function bindingAssignmentEntries(
+  expression: ts.Expression,
+): BindingAssignmentEntry[] {
+  const target = assignmentTarget(expression);
+  let entries: BindingAssignmentEntry[] = [];
+  if (ts.isIdentifier(target.expression))
+    entries = [{ variableName: target.expression.text }];
+  if (ts.isObjectLiteralExpression(target.expression))
+    entries = target.expression.properties.flatMap(objectEntries);
+  if (ts.isArrayLiteralExpression(target.expression))
+    entries = target.expression.elements.flatMap(arrayEntries);
+  if (ts.isSpreadElement(target.expression))
+    entries = unsupported(bindingAssignmentEntries(target.expression.expression));
+  return target.unsupported ? unsupported(entries) : entries;
+}

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

@@ -0,0 +1,217 @@
+import ts from 'typescript';
+import {
+  identifierMatchesDeclaration,
+} from './002-symbol-import-bindings.js';
+import {
+  isUnshadowedCommonJsExportExpression,
+} from './018-package-commonjs-syntax.js';
+
+function transparentUse(node: ts.Node): ts.Node {
+  const parent = node.parent;
+  if (parent && (ts.isParenthesizedExpression(parent)
+    || ts.isAsExpression(parent)
+    || ts.isSatisfiesExpression(parent)
+    || ts.isTypeAssertionExpression(parent)
+    || ts.isNonNullExpression(parent)))
+    return transparentUse(parent);
+  return node;
+}
+
+function assignmentOperator(kind: ts.SyntaxKind): boolean {
+  return kind >= ts.SyntaxKind.FirstAssignment
+    && kind <= ts.SyntaxKind.LastAssignment;
+}
+
+function directWriteTarget(node: ts.Node): boolean {
+  const use = transparentUse(node);
+  const parent = use.parent;
+  if (!parent) return false;
+  if (ts.isBinaryExpression(parent))
+    return parent.left === use && assignmentOperator(parent.operatorToken.kind);
+  if (ts.isDeleteExpression(parent))
+    return parent.expression === use;
+  if (ts.isPrefixUnaryExpression(parent)
+    || ts.isPostfixUnaryExpression(parent))
+    return parent.operand === use;
+  return (ts.isForInStatement(parent) || ts.isForOfStatement(parent))
+    && parent.initializer === use;
+}
+
+type MemberContainer = ts.ObjectLiteralExpression | ts.ClassLikeDeclaration;
+type StableMember = ts.ObjectLiteralElementLike | ts.ClassElement;
+
+function memberContainer(
+  declaration: ts.Identifier,
+): MemberContainer | undefined {
+  const parent = declaration.parent;
+  if (ts.isClassDeclaration(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
+    : undefined;
+}
+
+function declaredMemberName(node: ts.Node): string | undefined {
+  if (ts.isIdentifier(node) || ts.isPrivateIdentifier(node))
+    return node.text;
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+    || ts.isNumericLiteral(node)) return node.text;
+  return undefined;
+}
+
+function accessedMemberName(node: ts.Node): string | undefined {
+  if (ts.isPropertyAccessExpression(node)) return node.name.text;
+  if (!ts.isElementAccessExpression(node)) return undefined;
+  const argument = node.argumentExpression;
+  return argument && (ts.isStringLiteral(argument)
+    || ts.isNoSubstitutionTemplateLiteral(argument))
+    ? argument.text
+    : undefined;
+}
+
+function memberName(node: ts.Node): string | undefined {
+  return declaredMemberName(node) ?? accessedMemberName(node);
+}
+
+function matchingMember(
+  value: MemberContainer,
+  name: string,
+): 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));
+  const matches = members.filter((member) =>
+    'name' in member && member.name && memberName(member.name) === name);
+  if (matches.length === 1) return matches[0];
+  const implemented = matches.filter((member) => callableMember(member)?.body);
+  return implemented.length === 1 ? implemented[0] : undefined;
+}
+
+function callableMember(
+  member: StableMember,
+): ts.FunctionLikeDeclaration | undefined {
+  if (ts.isMethodDeclaration(member)) return member;
+  if (ts.isPropertyAssignment(member)
+    && (ts.isArrowFunction(member.initializer)
+      || ts.isFunctionExpression(member.initializer)))
+    return member.initializer;
+  if (ts.isPropertyDeclaration(member) && member.initializer
+    && (ts.isArrowFunction(member.initializer)
+      || ts.isFunctionExpression(member.initializer)))
+    return member.initializer;
+  return undefined;
+}
+
+function containsThis(node: ts.Node): boolean {
+  let found = false;
+  const visit = (child: ts.Node): void => {
+    if (found) return;
+    if (child.kind === ts.SyntaxKind.ThisKeyword) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(child, visit);
+  };
+  visit(node);
+  return found;
+}
+
+function invokedMember(node: ts.Node): boolean {
+  const use = transparentUse(node);
+  const parent = use.parent;
+  return Boolean(parent && ts.isCallExpression(parent)
+    && parent.expression === use);
+}
+
+type MemberAccess = ts.PropertyAccessExpression | ts.ElementAccessExpression;
+
+function receiverAccess(
+  node: ts.Node,
+): MemberAccess | undefined {
+  const parent = node.parent;
+  if (!parent || (!ts.isPropertyAccessExpression(parent)
+    && !ts.isElementAccessExpression(parent))
+    || parent.expression !== node || directWriteTarget(parent)) return undefined;
+  return parent;
+}
+
+function stableMemberUse(
+  access: MemberAccess,
+  member: StableMember,
+): boolean {
+  if (!invokedMember(access)) return !ts.isGetAccessor(member)
+    && !ts.isSetAccessor(member);
+  const callable = callableMember(member);
+  return Boolean(callable && !containsThis(callable));
+}
+
+function memberReceiverUse(
+  node: ts.Node,
+  declaration: ts.Identifier,
+): boolean {
+  const access = receiverAccess(node);
+  if (!access) return false;
+  const name = memberName(access);
+  const value = memberContainer(declaration);
+  const member = name && value ? matchingMember(value, name) : undefined;
+  return member ? stableMemberUse(access, member) : false;
+}
+
+function commonJsExportUse(node: ts.Node): boolean {
+  const parent = node.parent;
+  return Boolean(parent && ts.isBinaryExpression(parent)
+    && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken
+    && parent.right === node
+    && isUnshadowedCommonJsExportExpression(parent.left)
+    && ts.isExpressionStatement(parent.parent)
+    && ts.isSourceFile(parent.parent.parent));
+}
+
+function esmExportUse(node: ts.Node): boolean {
+  const parent = node.parent;
+  return Boolean(parent && (ts.isExportSpecifier(parent)
+    || (ts.isExportAssignment(parent) && parent.expression === node)));
+}
+
+function inertUnaryUse(node: ts.Node): boolean {
+  const parent = node.parent;
+  return Boolean(parent && ((ts.isVoidExpression(parent)
+    || ts.isTypeOfExpression(parent)) && parent.expression === node));
+}
+
+function safeReferenceUse(
+  node: ts.Identifier,
+  declaration: ts.Identifier,
+): boolean {
+  const use = transparentUse(node);
+  return memberReceiverUse(use, declaration)
+    || commonJsExportUse(use)
+    || esmExportUse(use)
+    || inertUnaryUse(use);
+}
+
+export function stableLocalValueReference(
+  source: ts.SourceFile,
+  declaration: ts.Identifier,
+): boolean {
+  const start = declaration.getStart(source);
+  const end = declaration.getEnd();
+  let stable = true;
+  const visit = (node: ts.Node): void => {
+    if (!stable) return;
+    if (ts.isIdentifier(node) && node !== declaration
+      && identifierMatchesDeclaration(node, start, end)
+      && !safeReferenceUse(node, declaration)) {
+      stable = false;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return stable;
+}

package/src/parsers/021-binding-visibility.ts

@@ -0,0 +1,152 @@
+import ts from 'typescript';
+import type { LexicalScopeFact } from '../types.js';
+import {
+  declarationAt,
+  enclosingCaseClause,
+  executionScope,
+  lexicalScopeChain,
+  sameScope,
+  type BindingLexicalIndex,
+  type BindingLexicalSite,
+  type BindingSiteCandidate,
+  type VisibleBinding,
+} from './011-binding-lexical-scope.js';
+
+function reachingSites(
+  index: BindingLexicalIndex,
+  variableName: string,
+  useStart: number,
+  useChain: readonly LexicalScopeFact[],
+  declaration: BindingLexicalSite,
+): BindingLexicalSite[] {
+  const useExecution = executionScope(useChain);
+  return index.sites.filter((site) =>
+    site.variableName === variableName
+    && site.declarationKey === declaration.declarationKey
+    && site.startOffset < useStart
+    && (site.flow === 'declaration'
+      || sameScope(site.executionScope, useExecution)))
+    .sort((left, right) =>
+      right.startOffset - left.startOffset
+      || right.endOffset - left.endOffset);
+}
+
+function enclosingLoops(node: ts.Node): ts.IterationStatement[] {
+  const loops: ts.IterationStatement[] = [];
+  let current: ts.Node | undefined = node.parent;
+  while (current && !ts.isSourceFile(current)
+    && !ts.isFunctionLike(current)) {
+    if (ts.isIterationStatement(current, false)) loops.push(current);
+    current = current.parent;
+  }
+  return loops;
+}
+
+function unsupportedAssignmentFlow(
+  index: BindingLexicalIndex,
+  variableName: string,
+  useNode: ts.Node,
+  useStart: number,
+  useChain: readonly LexicalScopeFact[],
+  declaration: BindingLexicalSite,
+): boolean {
+  const useExecution = executionScope(useChain);
+  const loops = enclosingLoops(useNode);
+  return index.sites.some((site) => {
+    if (site.flow !== 'assignment'
+      || site.variableName !== variableName
+      || site.declarationKey !== declaration.declarationKey) return false;
+    if (!sameScope(site.executionScope, useExecution)) return true;
+    return site.startOffset > useStart && loops.some((loop) =>
+      site.node.pos >= loop.pos && site.node.end <= loop.end);
+  });
+}
+
+function candidatesAtSite<T>(
+  candidates: readonly BindingSiteCandidate<T>[],
+  site: BindingLexicalSite,
+): BindingSiteCandidate<T>[] {
+  return candidates.filter((candidate) =>
+    candidate.variableName === site.variableName
+    && candidate.bindingSiteStartOffset === site.startOffset
+    && candidate.bindingSiteEndOffset === site.endOffset);
+}
+
+function compatibleCaseClause(
+  site: BindingLexicalSite,
+  useNode: ts.Node,
+  source: ts.SourceFile,
+): boolean {
+  if (site.caseClauseStartOffset === undefined
+    || site.caseClauseEndOffset === undefined) return true;
+  const clause = enclosingCaseClause(useNode);
+  return clause?.getStart(source) === site.caseClauseStartOffset
+    && clause.getEnd() === site.caseClauseEndOffset;
+}
+
+type VisibleBindingReason = NonNullable<VisibleBinding<unknown>['reason']>;
+
+function declarationFailure(
+  declaration: BindingLexicalSite,
+  after: boolean,
+  useNode: ts.Node,
+  source: ts.SourceFile,
+): VisibleBindingReason | undefined {
+  if (declaration.flow === 'shadow') return 'binding_flow_unsupported';
+  if (declaration.declarationKind === 'var') return 'unsupported_var_binding';
+  if (!compatibleCaseClause(declaration, useNode, source))
+    return 'binding_flow_unsupported';
+  return after ? 'binding_declared_after_call' : undefined;
+}
+
+function matchedBinding<T>(
+  candidates: readonly BindingSiteCandidate<T>[],
+  site: BindingLexicalSite,
+): VisibleBinding<T> | undefined {
+  const matches = candidatesAtSite(candidates, site);
+  if (matches.length === 0) return {
+    status: 'unresolved',
+    reason: site.flow === 'assignment'
+      ? 'unsupported_reaching_assignment'
+      : 'binding_not_found',
+  };
+  if (matches.length > 1) return { status: 'ambiguous' };
+  return matches[0] ? { status: 'resolved', candidate: matches[0] } : undefined;
+}
+
+export function selectVisibleBinding<T>(
+  index: BindingLexicalIndex,
+  candidates: readonly BindingSiteCandidate<T>[],
+  variableName: string,
+  useNode: ts.Node,
+): VisibleBinding<T> {
+  const useStart = useNode.getStart(index.source);
+  const useChain = lexicalScopeChain(useNode, index.source);
+  const declaration = declarationAt(index.sites, variableName, useStart, useChain);
+  if (declaration.ambiguous) return { status: 'ambiguous' };
+  if (!declaration.site) return { status: 'unresolved', reason: 'binding_not_found' };
+  const failure = declarationFailure(
+    declaration.site, declaration.after, useNode, index.source,
+  );
+  if (failure) return { status: 'unresolved', reason: failure };
+  if (unsupportedAssignmentFlow(
+    index, variableName, useNode, useStart, useChain, declaration.site,
+  )) return {
+    status: 'unresolved',
+    reason: 'unsupported_reaching_assignment',
+  };
+  const site = reachingSites(
+    index, variableName, useStart, useChain, declaration.site,
+  )[0];
+  if (!site) return { status: 'unresolved', reason: 'binding_not_found' };
+  const matched = matchedBinding(candidates, site);
+  if (!matched || matched.status !== 'resolved') return matched ?? {
+    status: 'unresolved', reason: 'binding_not_found',
+  };
+  return {
+    ...matched,
+    site,
+    declarationSite: declaration.site,
+    scopeIndex: declaration.scopeIndex,
+  };
+}

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

@@ -3,6 +3,7 @@ import {
   classifyODataPathIntent,
   normalizeODataOperationInvocationPath,
 } from '../linker/odata-path-normalizer.js';
+import { analyzeODataPathStructure } from '../linker/005-odata-path-structure.js';
 
 export type OperationPathStatus = 'static' | 'ambiguous' | 'dynamic' | 'unknown';
 
@@ -284,7 +285,11 @@ function normalizedCandidate(value: string, method: string): string[] {
   if (invocation?.wasInvocation) return [invocation.normalizedOperationPath];
   const intent = classifyODataPathIntent(value, method);
   if (intent.kind.startsWith('entity_')) return [];
-  if (!value.startsWith('/') || value.slice(1).includes('/') || value.includes('?')) return [];
+  const structure = analyzeODataPathStructure(value);
+  if (structure.status !== 'valid' || !value.startsWith('/')
+    || structure.segments.length !== 1
+    || structure.queryIndex !== undefined)
+    return [];
   return [value];
 }
 

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

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import ts from 'typescript';
 import { externalHttpTarget } from '../linker/external-http-target.js';
-import type { OutboundCallFact } from '../types.js';
+import type { OutboundCallFact, ServiceBindingFact } from '../types.js';
 import { normalizePath, stripQuotes } from '../utils/path-utils.js';
 import { summarizeExpression } from '../utils/redaction.js';
 import { classifyODataPathIntent } from '../linker/odata-path-normalizer.js';
@@ -461,16 +461,23 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
   visit(source);
   return calls;
 }
-export function containsSupportedOutboundCall(node: ts.Node): boolean {
+export function containsSupportedOutboundCall(
+  node: ts.Node,
+  classified?: readonly ClassifiedOutboundCall[],
+): boolean {
   const source = node.getSourceFile();
   const start = node.getFullStart();
   const end = node.getEnd();
-  return classifyOutboundCallsInSource(source, source.fileName).some((call) => call.node.getStart(source) >= start && call.node.getEnd() <= end);
+  const calls = classified ?? classifyOutboundCallsInSource(source, source.fileName);
+  return calls.some((call) =>
+    call.node.getStart(source) >= start && call.node.getEnd() <= end);
 }
 export async function parseOutboundCalls(
   repoPath: string,
   filePath: string,
   context?: RepositorySourceContext,
+  classified?: readonly ClassifiedOutboundCall[],
+  preparedBindings?: readonly ServiceBindingFact[],
 ): Promise<OutboundCallFact[]> {
   const snapshot = context?.get(filePath);
   const text = snapshot?.text
@@ -479,13 +486,19 @@ export async function parseOutboundCalls(
     filePath, text, ts.ScriptTarget.Latest, true,
     filePath.endsWith('.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS,
   );
-  const bindingNames = new Set((await parseServiceBindings(
+  const bindings = preparedBindings ?? await parseServiceBindings(
     repoPath, filePath, context,
-  )).map((binding) => binding.variableName));
+  );
+  const bindingNames = new Set(bindings.map((binding) => binding.variableName));
   const importedWrappers = await parseImportedWrapperCalls(
     repoPath, filePath, source, bindingNames, context,
   );
-  return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...importedWrappers, ...parseLocalServiceCalls(text, filePath, source)];
+  const nativeCalls = classified ?? classifyOutboundCallsInSource(source, filePath);
+  return [
+    ...nativeCalls.map((call) => call.fact),
+    ...importedWrappers,
+    ...parseLocalServiceCalls(text, filePath, source),
+  ];
 }
 function parseLocalServiceCalls(
   text: string,

package/src/parsers/package-json-parser.ts

@@ -7,11 +7,49 @@ interface ParsePackageJsonOptions {
 }
 export interface PackageJsonSnapshot {
   facts: PackageFacts;
+  manifest: PackageEntrypointManifest;
   rawText: string;
 }
+export interface PackageEntrypointManifest {
+  mainPresent: boolean;
+  main: string | null;
+  modulePresent: boolean;
+  module: string | null;
+  exportsPresent: boolean;
+  exportsValue: unknown;
+}
+function emptyManifest(): PackageEntrypointManifest {
+  return {
+    mainPresent: false,
+    main: null,
+    modulePresent: false,
+    module: null,
+    exportsPresent: false,
+    exportsValue: null,
+  };
+}
+function entrypointManifest(
+  json: Record<string, unknown>,
+): PackageEntrypointManifest {
+  const mainPresent = Object.hasOwn(json, 'main');
+  const modulePresent = Object.hasOwn(json, 'module');
+  const exportsPresent = Object.hasOwn(json, 'exports');
+  return {
+    mainPresent,
+    main: typeof json.main === 'string' ? json.main : null,
+    modulePresent,
+    module: typeof json.module === 'string' ? json.module : null,
+    exportsPresent,
+    exportsValue: exportsPresent ? json.exports : null,
+  };
+}
 function emptyPackageFacts(): PackageFacts {
   return { dependencies: {}, cdsRequires: [], scripts: {} };
 }
+function isMissingFileError(error: unknown): boolean {
+  return typeof error === 'object' && error !== null
+    && 'code' in error && error.code === 'ENOENT';
+}
 function recordOfString(value: unknown): Record<string, string> {
   if (!value || typeof value !== 'object') return {};
   return Object.fromEntries(
@@ -66,6 +104,7 @@ export async function loadPackageJsonSnapshot(
     const json = JSON.parse(raw) as Record<string, unknown>;
     return {
       rawText: raw,
+      manifest: entrypointManifest(json),
       facts: {
         packageName: typeof json.name === 'string' ? json.name : undefined,
         packageVersion:
@@ -79,10 +118,13 @@ export async function loadPackageJsonSnapshot(
       },
     };
   } catch (error) {
-    const missing = typeof error === 'object' && error !== null
-      && 'code' in error && error.code === 'ENOENT';
+    const missing = isMissingFileError(error);
     if (!options.strict || (options.allowMissing && missing))
-      return { facts: emptyPackageFacts(), rawText: '' };
+      return {
+        facts: emptyPackageFacts(),
+        manifest: emptyManifest(),
+        rawText: '',
+      };
     throw error;
   }
 }