@saptools/service-flow 0.1.69 → 0.1.72

package/src/parsers/event-environment-reference.ts

@@ -0,0 +1,231 @@
+import { posix } from 'node:path';
+import ts from 'typescript';
+import { normalizePath } from '../utils/path-utils.js';
+import { resolveBinding } from './query-entity-resolution.js';
+import {
+  collectSymbolImportBindings,
+  lexicalIdentifierDeclaration,
+  type SymbolImportBinding,
+} from './symbol-import-bindings.js';
+import type { RepositorySourceContext } from './ts-project.js';
+import { EVENT_ENVIRONMENT_KEY_ALLOWLIST } from
+  './environment-declarations.js';
+
+export type EventEnvironmentTransform = 'toUpperCase' | 'toLowerCase';
+
+export interface EventEnvironmentReference {
+  status: 'resolved' | 'refused';
+  sourceKey: string;
+  environmentKey?: string;
+  transforms: EventEnvironmentTransform[];
+  sourceFile?: string;
+  startOffset?: number;
+  endOffset?: number;
+  reason?: string;
+}
+
+export type EventEnvironmentReferenceResolver = (
+  expression: ts.Expression,
+) => EventEnvironmentReference | undefined;
+
+interface ResolutionContext {
+  sources: RepositorySourceContext;
+  source: ts.SourceFile;
+  sourceFile: string;
+  depth: number;
+  seen: Set<string>;
+}
+
+const maxEnvironmentReferenceDepth = 6;
+const allowedEnvironmentKeys = new Set<string>(
+  EVENT_ENVIRONMENT_KEY_ALLOWLIST,
+);
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expression)
+    || ts.isAsExpression(expression)
+    || ts.isSatisfiesExpression(expression)
+    || ts.isTypeAssertionExpression(expression)
+    || ts.isNonNullExpression(expression))
+    return unwrapExpression(expression.expression);
+  return expression;
+}
+
+function processEnvironmentKey(
+  expression: ts.Expression,
+): string | undefined {
+  if (!ts.isPropertyAccessExpression(expression)
+    || !ts.isPropertyAccessExpression(expression.expression)
+    || !ts.isIdentifier(expression.expression.expression)
+    || expression.expression.expression.text !== 'process'
+    || expression.expression.name.text !== 'env'
+    || lexicalIdentifierDeclaration(expression.expression.expression))
+    return undefined;
+  return expression.name.text;
+}
+
+function relativeCandidates(
+  callerFile: string,
+  specifier: string,
+): string[] {
+  const base = normalizePath(posix.normalize(
+    posix.join(posix.dirname(callerFile), specifier),
+  ));
+  return /\.[jt]s$/.test(base)
+    ? [base]
+    : [`${base}.ts`, `${base}.js`, `${base}/index.ts`, `${base}/index.js`];
+}
+
+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 exportedVariableInitializer(
+  source: ts.SourceFile,
+  name: string,
+): ts.Expression | undefined {
+  const exportNames = new Set(source.statements.flatMap((statement) =>
+    ts.isExportDeclaration(statement) && !statement.moduleSpecifier
+      && statement.exportClause && ts.isNamedExports(statement.exportClause)
+      ? statement.exportClause.elements.map((element) =>
+          element.propertyName?.text ?? element.name.text)
+      : []));
+  for (const statement of source.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    const exported = ts.canHaveModifiers(statement)
+      && ts.getModifiers(statement)?.some((modifier) =>
+        modifier.kind === ts.SyntaxKind.ExportKeyword);
+    for (const declaration of statement.declarationList.declarations)
+      if (ts.isIdentifier(declaration.name)
+        && declaration.name.text === name
+        && (exported || exportNames.has(name))
+        && (statement.declarationList.flags & ts.NodeFlags.Const) !== 0)
+        return declaration.initializer;
+  }
+  return undefined;
+}
+
+function importedIdentifier(
+  identifier: ts.Identifier,
+  context: ResolutionContext,
+): { source: ts.SourceFile; sourceFile: string;
+  initializer: ts.Expression } | undefined {
+  const binding = bindingFor(
+    identifier, collectSymbolImportBindings(context.source),
+  );
+  if (!binding || binding.typeOnly || binding.moduleKind !== 'relative'
+    || !binding.importedName) return undefined;
+  const candidates = relativeCandidates(
+    context.sourceFile, binding.rawModuleSpecifier,
+  ).flatMap((filePath) => {
+    const snapshot = context.sources.get(filePath);
+    return snapshot ? [{ sourceFile: filePath, source: snapshot.sourceFile() }]
+      : [];
+  });
+  if (candidates.length !== 1 || !candidates[0]) return undefined;
+  const initializer = exportedVariableInitializer(
+    candidates[0].source, binding.importedName,
+  );
+  return initializer ? { ...candidates[0], initializer } : undefined;
+}
+
+function transformedReference(
+  expression: ts.CallExpression,
+  context: ResolutionContext,
+): EventEnvironmentReference | undefined {
+  if (!ts.isPropertyAccessExpression(expression.expression)) return undefined;
+  const method = expression.expression.name.text;
+  const base = resolveEnvironmentReference(
+    expression.expression.expression, context,
+  );
+  if (!base) return undefined;
+  if (expression.arguments.length !== 0
+    || !['toUpperCase', 'toLowerCase'].includes(method)) return {
+    ...base,
+    status: 'refused',
+    reason: 'event_environment_transform_unsupported',
+  };
+  return base.status === 'resolved'
+    ? {
+        ...base,
+        transforms: [
+          ...base.transforms, method as EventEnvironmentTransform,
+        ],
+      }
+    : base;
+}
+
+function identifierReference(
+  identifier: ts.Identifier,
+  context: ResolutionContext,
+): EventEnvironmentReference | undefined {
+  const local = resolveBinding(identifier, identifier);
+  if (local.declaration && local.initializer && local.immutable)
+    return resolveEnvironmentReference(local.initializer, context);
+  const imported = importedIdentifier(identifier, context);
+  if (!imported) return undefined;
+  return resolveEnvironmentReference(imported.initializer, {
+    ...context,
+    source: imported.source,
+    sourceFile: imported.sourceFile,
+    depth: context.depth + 1,
+  });
+}
+
+function resolveEnvironmentReference(
+  expression: ts.Expression,
+  context: ResolutionContext,
+): EventEnvironmentReference | undefined {
+  const sourceKey = expression.getText(context.source);
+  if (context.depth >= maxEnvironmentReferenceDepth
+    || context.seen.has(`${context.sourceFile}\0${sourceKey}`)) return {
+    status: 'refused', sourceKey, transforms: [],
+    reason: 'event_environment_reference_ambiguous',
+  };
+  const seen = new Set(context.seen).add(
+    `${context.sourceFile}\0${sourceKey}`,
+  );
+  const next = { ...context, depth: context.depth + 1, seen };
+  const value = unwrapExpression(expression);
+  const key = processEnvironmentKey(value);
+  if (key && allowedEnvironmentKeys.has(key)) return {
+    status: 'resolved', sourceKey, environmentKey: key, transforms: [],
+    sourceFile: context.sourceFile,
+    startOffset: value.getStart(context.source), endOffset: value.getEnd(),
+  };
+  if (key) return undefined;
+  if (ts.isCallExpression(value))
+    return transformedReference(value, next);
+  return ts.isIdentifier(value)
+    ? identifierReference(value, next) : undefined;
+}
+
+export function createEventEnvironmentReferenceResolver(
+  sources: RepositorySourceContext,
+  source: ts.SourceFile,
+  sourceFile: string,
+): EventEnvironmentReferenceResolver {
+  return (expression) => resolveEnvironmentReference(expression, {
+    sources, source, sourceFile, depth: 0, seen: new Set(),
+  });
+}
+
+export function applyEventEnvironmentTransforms(
+  value: string,
+  transforms: readonly EventEnvironmentTransform[],
+): string {
+  return transforms.reduce((current, transform) =>
+    transform === 'toUpperCase'
+      ? current.toUpperCase() : current.toLowerCase(), value);
+}

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);
+  };
+}