@saptools/service-flow 0.1.70 → 0.1.73

package/src/parsers/event-loop-registration.ts

@@ -0,0 +1,132 @@
+import ts from 'typescript';
+import {
+  collectStringConstantLookups,
+  type StaticStringConstant,
+} from './string-constant-lookups.js';
+import { resolveBinding } from './query-entity-resolution.js';
+import { lexicalIdentifierDeclaration } from './symbol-import-bindings.js';
+
+const loopValueCap = 32;
+const loopExpressionLimit = 256;
+
+function unwrap(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression))
+    return unwrap(expression.expression);
+  return expression;
+}
+
+function stringArray(expression: ts.Expression): string[] | undefined {
+  const value = unwrap(expression);
+  if (!ts.isArrayLiteralExpression(value)) return undefined;
+  const strings = value.elements.flatMap((element) => {
+    const item = ts.isSpreadElement(element) ? undefined : unwrap(element);
+    return item && ts.isStringLiteralLike(item) ? [item.text] : [];
+  });
+  return strings.length === value.elements.length ? strings : undefined;
+}
+
+function identifierArray(
+  identifier: ts.Identifier,
+): string[] | undefined {
+  const binding = resolveBinding(identifier, identifier);
+  return binding.immutable && binding.initializer
+    ? stringArray(binding.initializer) : undefined;
+}
+
+function orderedValues(values: StaticStringConstant[]): string[] {
+  return [...values]
+    .sort((left, right) =>
+      left.declarationStartOffset - right.declarationStartOffset)
+    .map((item) => item.value);
+}
+
+function objectValues(
+  expression: ts.CallExpression,
+  source: ts.SourceFile,
+): string[] | undefined {
+  if (!ts.isPropertyAccessExpression(expression.expression))
+    return undefined;
+  const root = expression.expression.expression;
+  if (!ts.isIdentifier(root) || root.text !== 'Object'
+    || lexicalIdentifierDeclaration(root)
+    || expression.expression.name.text !== 'values'
+    || expression.arguments.length !== 1) return undefined;
+  const argument = expression.arguments[0];
+  if (!argument || !ts.isIdentifier(argument)) return undefined;
+  const lookups = collectStringConstantLookups(source);
+  const prefix = `${argument.text}.`;
+  const refused = [...lookups.refusedMembers.keys()].some((key) =>
+    key.startsWith(prefix));
+  const values = [
+    ...lookups.enumMembers.values(),
+    ...lookups.objectProperties.values(),
+  ].filter((item) => item.key.startsWith(prefix));
+  return !refused && values.length > 0 ? orderedValues(values) : undefined;
+}
+
+function staticCollectionValues(
+  expression: ts.Expression,
+  source: ts.SourceFile,
+): string[] | undefined {
+  const value = unwrap(expression);
+  if (ts.isArrayLiteralExpression(value)) return stringArray(value);
+  if (ts.isIdentifier(value)) return identifierArray(value);
+  return ts.isCallExpression(value) ? objectValues(value, source) : undefined;
+}
+
+function enclosingForEach(
+  node: ts.Node,
+): ts.CallExpression | undefined {
+  let current: ts.Node | undefined = node.parent;
+  while (current && !ts.isSourceFile(current)) {
+    if ((ts.isArrowFunction(current) || ts.isFunctionExpression(current))
+      && ts.isCallExpression(current.parent)
+      && current.parent.arguments.includes(current)
+      && ts.isPropertyAccessExpression(current.parent.expression)
+      && current.parent.expression.name.text === 'forEach')
+      return current.parent;
+    if (ts.isFunctionLike(current)) return undefined;
+    current = current.parent;
+  }
+  return undefined;
+}
+
+function boundedExpression(
+  expression: ts.Expression,
+  source: ts.SourceFile,
+): string {
+  return expression.getText(source).slice(0, loopExpressionLimit);
+}
+
+export function eventLoopRegistrationEvidence(
+  node: ts.CallExpression,
+  source: ts.SourceFile,
+): Record<string, unknown> {
+  const loop = enclosingForEach(node);
+  if (!loop || !ts.isPropertyAccessExpression(loop.expression)) return {};
+  const collection = loop.expression.expression;
+  const values = staticCollectionValues(collection, source);
+  if (!values) return {
+    subscriptionRegisteredInLoop: true,
+    subscriptionLoopRegistrationStatus: 'unresolved',
+    subscriptionLoopUnresolvedReason:
+      'subscription_loop_collection_not_statically_enumerable',
+    subscriptionLoopCollectionExpression:
+      boundedExpression(collection, source),
+  };
+  const shown = values.slice(0, loopValueCap);
+  return {
+    subscriptionRegisteredInLoop: true,
+    subscriptionLoopRegistrationStatus: 'enumerated',
+    subscriptionLoopCollectionExpression:
+      boundedExpression(collection, source),
+    subscriptionLoopRegistrationCount: values.length,
+    subscriptionLoopValues: shown,
+    shownSubscriptionLoopValueCount: shown.length,
+    omittedSubscriptionLoopValueCount:
+      Math.max(0, values.length - shown.length),
+  };
+}

package/src/parsers/event-name-import-resolution.ts

@@ -0,0 +1,243 @@
+import { posix } from 'node:path';
+import ts from 'typescript';
+import { normalizePath } from '../utils/path-utils.js';
+import {
+  collectStringConstantLookups,
+  type StaticStringConstant,
+  type StaticStringLookupResult,
+  type StringConstantLookups,
+} from './string-constant-lookups.js';
+import {
+  collectSymbolImportBindings,
+  derivedMemberImportReference,
+  lexicalIdentifierDeclaration,
+  type SymbolImportBinding,
+  type SymbolImportReference,
+} from './symbol-import-bindings.js';
+import type { RepositorySourceContext } from './ts-project.js';
+
+interface ImportedMemberRequest {
+  binding: SymbolImportBinding;
+  containerName: string;
+  memberName?: string;
+}
+
+export type ImportedEventNameResult =
+  | { status: 'resolved'; constant: StaticStringConstant }
+  | { status: 'not_found' }
+  | {
+      status: 'refused';
+      reason: string;
+      packageImportReference?: SymbolImportReference;
+    };
+export type ImportedEventNameResolver = (
+  expression: ts.Expression,
+) => ImportedEventNameResult;
+
+function bindingFor(
+  identifier: ts.Identifier,
+  bindings: readonly SymbolImportBinding[],
+): SymbolImportBinding | undefined {
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration) return undefined;
+  const start = declaration.getStart(identifier.getSourceFile());
+  const end = declaration.getEnd();
+  const matches = bindings.filter((binding) =>
+    binding.localName === identifier.text
+    && binding.bindingSiteStartOffset === start
+    && binding.bindingSiteEndOffset === end);
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+function directMemberRequest(
+  expression: ts.PropertyAccessExpression,
+  bindings: readonly SymbolImportBinding[],
+): ImportedMemberRequest | undefined {
+  if (!ts.isIdentifier(expression.expression)) return undefined;
+  const binding = bindingFor(expression.expression, bindings);
+  if (!binding || binding.typeOnly || binding.importedName === null)
+    return undefined;
+  return {
+    binding,
+    containerName: binding.importedName,
+    memberName: expression.name.text,
+  };
+}
+
+function namespaceMemberRequest(
+  expression: ts.PropertyAccessExpression,
+  bindings: readonly SymbolImportBinding[],
+): ImportedMemberRequest | undefined {
+  const container = expression.expression;
+  if (!ts.isPropertyAccessExpression(container)
+    || !ts.isIdentifier(container.expression)) return undefined;
+  const binding = bindingFor(container.expression, bindings);
+  if (!binding || binding.typeOnly
+    || !['esm_namespace', 'cjs_namespace'].includes(binding.bindingKind))
+    return undefined;
+  return {
+    binding,
+    containerName: container.name.text,
+    memberName: expression.name.text,
+  };
+}
+
+function importedMemberRequest(
+  expression: ts.Expression,
+  bindings: readonly SymbolImportBinding[],
+): ImportedMemberRequest | undefined {
+  if (ts.isIdentifier(expression)) {
+    const binding = bindingFor(expression, bindings);
+    return binding && !binding.typeOnly && binding.importedName
+      ? { binding, containerName: binding.importedName }
+      : undefined;
+  }
+  if (!ts.isPropertyAccessExpression(expression)
+    || expression.questionDotToken) return undefined;
+  return directMemberRequest(expression, bindings)
+    ?? namespaceMemberRequest(expression, bindings);
+}
+
+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);
+  return undefined;
+}
+
+function importedAliasBinding(
+  identifier: ts.Identifier,
+  bindings: readonly SymbolImportBinding[],
+): SymbolImportBinding | undefined {
+  const direct = bindingFor(identifier, bindings);
+  if (direct) return direct;
+  const declaration = lexicalIdentifierDeclaration(identifier);
+  if (!declaration || !ts.isVariableDeclaration(declaration.parent))
+    return undefined;
+  const initializer = declaration.parent.initializer;
+  return initializer && ts.isIdentifier(initializer)
+    ? bindingFor(initializer, bindings) : undefined;
+}
+
+function unsupportedImportedContainer(
+  expression: ts.Expression,
+  bindings: readonly SymbolImportBinding[],
+): boolean {
+  const root = rootIdentifier(expression);
+  return Boolean(root && importedAliasBinding(root, bindings));
+}
+
+function constantImportReference(
+  request: ImportedMemberRequest,
+): SymbolImportReference | undefined {
+  const binding = request.binding;
+  if (!request.memberName) {
+    if (!binding.importedName) return undefined;
+    return {
+      ...binding,
+      referenceShape: 'identifier',
+      referencedMemberName: null,
+      requestedPublicName: binding.importedName,
+    };
+  }
+  if (binding.bindingKind !== 'esm_namespace'
+    && binding.bindingKind !== 'cjs_namespace')
+    return derivedMemberImportReference(binding, request.memberName);
+  const requestedPublicName =
+    `${request.containerName}.${request.memberName}`;
+  return {
+    ...binding,
+    referenceShape: 'namespace_member',
+    referencedMemberName: requestedPublicName,
+    requestedPublicName,
+  };
+}
+
+function relativeCandidates(
+  callerFile: string,
+  specifier: string,
+): string[] {
+  const base = normalizePath(posix.normalize(
+    posix.join(posix.dirname(callerFile), specifier),
+  ));
+  if (/\.[jt]s$/.test(base)) return [base];
+  return [
+    `${base}.ts`, `${base}.js`, `${base}/index.ts`, `${base}/index.js`,
+  ];
+}
+
+function targetLookups(
+  context: RepositorySourceContext,
+  callerFile: string,
+  request: ImportedMemberRequest,
+): StringConstantLookups[] {
+  if (request.binding.moduleKind !== 'relative') return [];
+  return relativeCandidates(
+    callerFile, request.binding.rawModuleSpecifier,
+  ).flatMap((candidate) => {
+    const snapshot = context.get(candidate);
+    return snapshot
+      ? [collectStringConstantLookups(snapshot.sourceFile())] : [];
+  });
+}
+
+function targetResult(
+  lookups: readonly StringConstantLookups[],
+  request: ImportedMemberRequest,
+): StaticStringLookupResult {
+  if (lookups.length !== 1) return {
+    status: 'refused',
+    reason: 'event_name_constant_container_ambiguous',
+  };
+  const key = request.memberName
+    ? `${request.containerName}.${request.memberName}`
+    : request.containerName;
+  const constant = request.memberName
+    ? lookups[0]?.enumMembers.get(key)
+      ?? lookups[0]?.objectProperties.get(key)
+    : lookups[0]?.identifiers.get(key);
+  if (constant && constant.exported && constant.stable)
+    return { status: 'resolved', constant };
+  const refusal = lookups[0]?.refusedMembers.get(key);
+  if (refusal) return { status: 'refused', reason: refusal.reason };
+  if (constant && !constant.exported) return {
+    status: 'refused',
+    reason: 'event_name_constant_container_not_exported',
+  };
+  return {
+    status: 'refused',
+    reason: 'event_name_constant_member_not_string',
+  };
+}
+
+export function createImportedEventNameResolver(
+  context: RepositorySourceContext,
+  source: ts.SourceFile,
+  sourceFile: string,
+): ImportedEventNameResolver {
+  const bindings = collectSymbolImportBindings(source);
+  return (expression): ImportedEventNameResult => {
+    const request = importedMemberRequest(expression, bindings);
+    if (!request) return unsupportedImportedContainer(expression, bindings)
+      ? {
+          status: 'refused',
+          reason: 'event_name_constant_container_ambiguous',
+        }
+      : { status: 'not_found' };
+    if (request.binding.moduleKind !== 'relative') {
+      const packageImportReference = constantImportReference(request);
+      return packageImportReference ? {
+        status: 'refused',
+        reason: 'event_name_constant_resolution_pending',
+        packageImportReference,
+      } : {
+        status: 'refused',
+        reason: 'event_name_constant_container_ambiguous',
+      };
+    }
+    return targetResult(targetLookups(context, sourceFile, request), request);
+  };
+}