@saptools/service-flow 0.1.63 → 0.1.65

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-EGBTHN7J.js";
+} from "./chunk-OONNRIDL.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/linker/002-call-evidence.ts

@@ -7,6 +7,7 @@ import {
   projectBounded,
   type BoundedProjection,
 } from '../utils/000-bounded-projection.js';
+import { extractPlaceholderKeys } from '../utils/001-placeholders.js';
 
 export interface LinkedOperationResolution {
   target?: {
@@ -200,10 +201,7 @@ function compactCandidateScores(
 }
 
 function placeholderKeys(values: Array<string | undefined>): string[] {
-  const keys = values.flatMap((value) => [...(value ?? '')
-    .matchAll(/\$\{([^}]*)\}/g)]
-    .map((match) => (match[1] ?? '').trim())
-    .filter(Boolean));
+  const keys = values.flatMap(extractPlaceholderKeys);
   return [...new Set(keys)].sort();
 }
 

package/src/linker/cross-repo-linker.ts

@@ -139,7 +139,7 @@ function insertCallEdge(db: Db, workspaceId: number, call: Record<string, unknow
   }
   if (isRemoteEntityCall) {
     const target = buildRemoteQueryTarget({ queryEntity: intent.entitySegment ?? call.query_entity, servicePath, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination: destination ? applyVariables(destination, vars) : undefined, isDynamic, parserWarning: evidence.parserWarning });
-    const entityKind = callType.replace('remote_entity_', 'remote_entity_');
+    const entityKind = callType;
     db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'HANDLER_ACCESSES_REMOTE_ENTITY', 'terminal', 'call', String(call.id), target.toKind, target.toId, Number(call.confidence ?? 0.5), JSON.stringify({ ...evidence, ...target.evidence, remoteEntityAccess: entityKind }), 0, generation);
     return { status: 'terminal', callType };
   }

package/src/linker/dynamic-edge-resolver.ts

@@ -1,3 +1,5 @@
+import { extractPlaceholderKeys, scanPlaceholders } from '../utils/001-placeholders.js';
+
 export interface RuntimeSubstitution {
   original?: string;
   effective?: string;
@@ -7,8 +9,6 @@ export interface RuntimeSubstitution {
   changed: boolean;
 }
 
-const PLACEHOLDER = /\$\{([^}]*)\}/g;
-
 export function applyVariables(
   template: string | undefined,
   vars: Record<string, string>,
@@ -17,9 +17,7 @@ export function applyVariables(
 }
 
 export function extractPlaceholders(template: string | undefined): string[] {
-  return [...(template ?? '').matchAll(PLACEHOLDER)]
-    .map((m) => (m[1] ?? '').trim())
-    .filter(Boolean);
+  return extractPlaceholderKeys(template);
 }
 
 export function matchRuntimeTemplate(
@@ -50,10 +48,15 @@ export function substituteVariables(
   const placeholders = [...new Set(extractPlaceholders(template))];
   const supplied = placeholders.filter((key) => Object.hasOwn(vars, key));
   const missing = placeholders.filter((key) => !Object.hasOwn(vars, key));
-  const effective = template.replace(PLACEHOLDER, (_m, key: string) => {
-    const trimmed = key.trim();
-    return Object.hasOwn(vars, trimmed) ? vars[trimmed] ?? '' : `\${${trimmed}}`;
-  });
+  let lastIndex = 0;
+  let effective = '';
+  for (const span of scanPlaceholders(template)) {
+    const trimmed = span.key.trim();
+    const replacement = Object.hasOwn(vars, trimmed) ? vars[trimmed] ?? '' : `\${${trimmed}}`;
+    effective += template.slice(lastIndex, span.start) + replacement;
+    lastIndex = span.end;
+  }
+  effective += template.slice(lastIndex);
   return {
     original: template,
     effective,
@@ -67,10 +70,10 @@ export function substituteVariables(
 function runtimeTemplatePattern(template: string): string {
   let pattern = '';
   let lastIndex = 0;
-  for (const match of template.matchAll(PLACEHOLDER)) {
-    pattern += escapeRegex(template.slice(lastIndex, match.index));
+  for (const span of scanPlaceholders(template)) {
+    pattern += escapeRegex(template.slice(lastIndex, span.start));
     pattern += '([^/]+?)';
-    lastIndex = (match.index ?? 0) + match[0].length;
+    lastIndex = span.end;
   }
   return `${pattern}${escapeRegex(template.slice(lastIndex))}`;
 }

package/src/linker/service-resolver.ts

@@ -1,4 +1,5 @@
 import type { Db } from '../db/connection.js';
+import { extractPlaceholderKeys } from '../utils/001-placeholders.js';
 import { canonicalImplementationEvidence } from './000-implementation-candidates.js';
 export interface OperationTarget {
   operationId: number;
@@ -72,7 +73,8 @@ export function resolveOperation(
   },
   workspaceId?: number,
 ): OperationResolution {
-  const missing = [signals.servicePath, signals.alias, signals.destination, signals.operationPath].flatMap((value) => [...(value ?? '').matchAll(/\$\{([^}]*)\}/g)].map((match) => (match[1] ?? '').trim())).filter(Boolean);
+  const missing = [signals.servicePath, signals.alias, signals.destination, signals.operationPath]
+    .flatMap(extractPlaceholderKeys);
   if (missing.length > 0)
     return {
       status: 'dynamic',

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

@@ -2,6 +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 type { RepositorySourceContext } from './ts-project.js';
 
 export interface HelperBinding {
@@ -43,7 +44,7 @@ function stringValue(node: ts.Expression | undefined): string | undefined {
 }
 
 function placeholders(value?: string): string[] {
-  return [...(value ?? '').matchAll(/\$\{([^}]*)\}/g)].map((m) => (m[1] ?? '').trim()).filter(Boolean);
+  return extractPlaceholderKeys(value);
 }
 
 export function connectFactFromCall(call: ts.CallExpression): Omit<HelperBinding, 'exportedName' | 'sourceFile' | 'sourceLine'> | undefined {

package/src/parsers/symbol-parser.ts

@@ -2,7 +2,10 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import ts from 'typescript';
 import type { ExecutableSymbolFact, SymbolCallFact } from '../types.js';
-import { containsSupportedOutboundCall } from './outbound-call-parser.js';
+import {
+  classifyOutboundCallsInSource,
+  containsSupportedOutboundCall,
+} from './outbound-call-parser.js';
 import type { RepositorySourceContext } from './ts-project.js';
 import { normalizePath } from '../utils/path-utils.js';
 
@@ -38,6 +41,76 @@ function exportDeclarations(source: ts.SourceFile): Map<string, string> {
 function isRelativeImport(value: string | undefined): boolean {
   return Boolean(value?.startsWith('.'));
 }
+type HandlerReferenceRelation =
+  | 'relative_import'
+  | 'package_import'
+  | 'indexed_local_symbol'
+  | 'relative_import_namespace_member';
+interface HandlerReferenceTarget {
+  calleeExpression: string;
+  calleeLocalName: string;
+  importSource?: string;
+  relation: HandlerReferenceRelation;
+  wrapperFunction?: string;
+}
+function directHandlerReferenceTarget(
+  expression: ts.Expression,
+  source: ts.SourceFile,
+  imports: Map<string, string>,
+  namespaceImports: Set<string>,
+): HandlerReferenceTarget | undefined {
+  if (ts.isIdentifier(expression)) {
+    const importSource = imports.get(expression.text);
+    return {
+      calleeExpression: expression.text,
+      calleeLocalName: expression.text,
+      importSource,
+      relation: importSource
+        ? isRelativeImport(importSource) ? 'relative_import' : 'package_import'
+        : 'indexed_local_symbol',
+    };
+  }
+  if (!ts.isPropertyAccessExpression(expression) || expression.questionDotToken
+    || !ts.isIdentifier(expression.expression) || !ts.isIdentifier(expression.name))
+    return undefined;
+  const objectName = expression.expression.text;
+  const memberName = expression.name.text;
+  const importSource = imports.get(objectName);
+  if (namespaceImports.has(objectName)) return {
+    calleeExpression: expression.getText(source),
+    calleeLocalName: memberName,
+    importSource,
+    relation: 'relative_import_namespace_member',
+  };
+  const qualifiedName = `${objectName}.${memberName}`;
+  return {
+    calleeExpression: qualifiedName,
+    calleeLocalName: qualifiedName,
+    importSource,
+    relation: importSource
+      ? isRelativeImport(importSource) ? 'relative_import' : 'package_import'
+      : 'indexed_local_symbol',
+  };
+}
+function handlerReferenceTarget(
+  expression: ts.Expression,
+  source: ts.SourceFile,
+  imports: Map<string, string>,
+  namespaceImports: Set<string>,
+): HandlerReferenceTarget | undefined {
+  const direct = directHandlerReferenceTarget(
+    expression, source, imports, namespaceImports,
+  );
+  if (direct) return direct;
+  if (!ts.isCallExpression(expression) || expression.questionDotToken
+    || expression.arguments.length !== 1) return undefined;
+  const inner = directHandlerReferenceTarget(
+    expression.arguments[0], source, imports, namespaceImports,
+  );
+  return inner
+    ? { ...inner, wrapperFunction: expression.expression.getText(source) }
+    : undefined;
+}
 function isObjectFunction(node: ts.Node): boolean {
   return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
 }
@@ -185,6 +258,11 @@ export async function parseExecutableSymbols(
   const calls: SymbolCallFact[] = [];
   const imports = new Map<string, string>();
   const namespaceImports = new Set<string>();
+  const eventSubscriptionOffsets = new Set(
+    classifyOutboundCallsInSource(source, sourceFile)
+      .filter((call) => call.fact.callType === 'async_subscribe')
+      .map((call) => call.node.getStart(source)),
+  );
   const exportNames = exportDeclarations(source);
   const objectExports = new Set<string>();
   const exportedClasses = new Set<string>();
@@ -305,6 +383,33 @@ export async function parseExecutableSymbols(
         const name = `event:${eventName}:${startLine}`;
         symbols.push({ kind: 'event_registration', localName: name, qualifiedName: `module:${sourceFile}#${name}`, sourceFile, startLine, endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: false, importExportEvidence: { source: 'synthetic_event_registration', eventName: eventArg.text, registrationLine: startLine, receiver } });
       }
+      if (eventSubscriptionOffsets.has(node.getStart(source))) {
+        const startLine = lineOf(source, node.getStart(source));
+        const handlerArgument = node.arguments[1];
+        const target = handlerArgument
+          ? handlerReferenceTarget(
+            handlerArgument, source, imports, namespaceImports,
+          )
+          : undefined;
+        const anchor = nearest(symbols, startLine);
+        if (target && anchor) calls.push({
+          callerQualifiedName: anchor.qualifiedName,
+          calleeExpression: target.calleeExpression,
+          calleeLocalName: target.calleeLocalName,
+          importSource: target.importSource,
+          sourceFile,
+          sourceLine: startLine,
+          evidence: {
+            relation: target.relation,
+            caller: anchor.qualifiedName,
+            targetName: target.calleeLocalName,
+            ...(target.wrapperFunction
+              ? { wrapperFunction: target.wrapperFunction }
+              : {}),
+            candidateStrategy: 'event_subscribe_handler_reference',
+          },
+        });
+      }
     }
     ts.forEachChild(node, visitEventRegistrationSymbols);
   };

package/src/trace/001-dynamic-identity.ts

@@ -1,4 +1,5 @@
 import type { Db } from '../db/connection.js';
+import { scanPlaceholders } from '../utils/001-placeholders.js';
 import type {
   DynamicTargetCandidate,
   DynamicTemplates,
@@ -131,10 +132,11 @@ function matchIdentityTemplate(
   identity: string,
   npmPackage: boolean,
 ): { key: string; value: string; normalizedIdentity: string } | undefined {
-  const matches = [...template.matchAll(/\$\{([^}]*)\}/g)];
-  if (matches.length !== 1 || !matches[0]?.[1]) return undefined;
-  const placeholder = matches[0][0];
-  const sentinel = 'dynamicplaceholdertoken';
+  const matches = scanPlaceholders(template);
+  const matchSpan = matches[0];
+  if (matches.length !== 1 || !matchSpan?.key) return undefined;
+  const placeholder = template.slice(matchSpan.start, matchSpan.end);
+  const sentinel = 'dynamic_placeholder_token';
   const normalizedTemplate = normalizeIdentity(template.replace(placeholder, sentinel));
   const [prefix, suffix, extra] = normalizedTemplate.split(sentinel);
   if (!prefix || !suffix || extra !== undefined) return undefined;
@@ -142,7 +144,7 @@ function matchIdentityTemplate(
   const match = new RegExp(`^${escapeRegex(prefix)}([a-z0-9]+)${escapeRegex(suffix)}$`)
     .exec(normalizedIdentity);
   if (!match?.[1]) return undefined;
-  return { key: matches[0][1].trim(), value: match[1], normalizedIdentity };
+  return { key: matchSpan.key.trim(), value: match[1], normalizedIdentity };
 }
 
 function competingIdentityKeys(
@@ -292,7 +294,7 @@ function normalizeIdentity(value: string, npmPackage = false): string {
     .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '');
+    .replace(/^_+|(?<!_)_+$/g, '');
 }
 
 function stringValue(value: unknown): string | undefined {

package/src/utils/001-placeholders.ts

@@ -0,0 +1,30 @@
+export interface PlaceholderSpan {
+  readonly start: number;
+  readonly end: number;
+  readonly key: string;
+}
+
+export function scanPlaceholders(value: string | undefined): readonly PlaceholderSpan[] {
+  const input = value ?? '';
+  const spans: PlaceholderSpan[] = [];
+  let cursor = 0;
+  while (cursor < input.length) {
+    const start = input.indexOf('${', cursor);
+    if (start < 0) break;
+    const closingBrace = input.indexOf('}', start + 2);
+    if (closingBrace < 0) break;
+    spans.push({
+      start,
+      end: closingBrace + 1,
+      key: input.slice(start + 2, closingBrace),
+    });
+    cursor = closingBrace + 1;
+  }
+  return spans;
+}
+
+export function extractPlaceholderKeys(value: string | undefined): string[] {
+  return scanPlaceholders(value)
+    .map((span) => span.key.trim())
+    .filter(Boolean);
+}

package/src/utils/redaction.ts

@@ -1,9 +1,49 @@
 const SENSITIVE = /authorization|cookie|token|secret|password|key|credential/i;
+const SENSITIVE_KEYWORD = /authorization|cookie|token|secret|password|key|credential/gi;
+
+interface RedactionSpan {
+  readonly start: number;
+  readonly end: number;
+  readonly keyword: string;
+}
+
+function isWhitespace(value: string | undefined): boolean {
+  return value !== undefined && /\s/u.test(value);
+}
+
+function redactionSpan(text: string, start: number, keyword: string): RedactionSpan | undefined {
+  let cursor = start + keyword.length;
+  while (isWhitespace(text[cursor])) cursor += 1;
+  if (text[cursor] !== ':' && text[cursor] !== '=') return undefined;
+  cursor += 1;
+  while (isWhitespace(text[cursor])) cursor += 1;
+  const candidateQuote = text[cursor];
+  const quote = candidateQuote === "'" || candidateQuote === '"' || candidateQuote === '`'
+    ? candidateQuote
+    : undefined;
+  if (quote !== undefined) cursor += 1;
+  const valueStart = cursor;
+  while (cursor < text.length && !/[,'"`}\s]/u.test(text[cursor] ?? '')) cursor += 1;
+  if (cursor === valueStart) return undefined;
+  if (quote !== undefined) {
+    if (text[cursor] !== quote) return undefined;
+    cursor += 1;
+  }
+  return { start, end: cursor, keyword };
+}
+
 export function redactText(text: string): string {
-  return text.replace(
-    /(authorization|cookie|token|secret|password|key|credential)\s*[:=]\s*(['"`]?)[^,'"`}\s]+\2/gi,
-    '$1: [REDACTED]'
-  );
+  let cursor = 0;
+  let output = '';
+  for (const match of text.matchAll(SENSITIVE_KEYWORD)) {
+    const start = match.index ?? 0;
+    if (start < cursor) continue;
+    const span = redactionSpan(text, start, match[0]);
+    if (span === undefined) continue;
+    output += text.slice(cursor, span.start) + `${span.keyword}: [REDACTED]`;
+    cursor = span.end;
+  }
+  return output + text.slice(cursor);
 }
 export function redactValue(value: unknown): unknown {
   if (Array.isArray(value)) return value.map(redactValue);