@saptools/service-flow 0.1.66 → 0.1.68

package/src/types.ts

@@ -160,8 +160,63 @@ export interface ServiceBindingFact {
   placeholders: string[];
   sourceFile: string;
   sourceLine: number;
+  bindingSiteStartOffset?: number;
+  bindingSiteEndOffset?: number;
+  sourceSymbolQualifiedName?: string;
+  ownerResolution?: ServiceBindingOwnerResolution;
   helperChain?: Array<Record<string, unknown>>;
 }
+export type ServiceBindingOwnerResolution =
+  | 'owned_exact'
+  | 'ownerless_file_scope'
+  | 'legacy_unknown';
+export type ServiceBindingReferenceStatus =
+  | 'resolved_exact'
+  | 'ambiguous'
+  | 'unresolved'
+  | 'not_applicable';
+export type ServiceBindingReferenceReason =
+  | 'binding_not_found'
+  | 'binding_declared_after_call'
+  | 'binding_scope_ambiguous'
+  | 'scope_chain_limit_exceeded'
+  | 'unsupported_reaching_assignment'
+  | 'unsupported_var_binding'
+  | 'binding_flow_unsupported';
+export interface LexicalScopeFact {
+  kind: 'source_file'
+    | 'module_block'
+    | 'function'
+    | 'class'
+    | 'loop'
+    | 'case_block'
+    | 'block'
+    | 'catch';
+  startOffset: number;
+  endOffset: number;
+}
+export interface ServiceBindingReference {
+  status: ServiceBindingReferenceStatus;
+  variableName?: string;
+  bindingSourceFile?: string;
+  bindingSiteStartOffset?: number;
+  bindingSiteEndOffset?: number;
+  resolutionStrategy?: 'lexical_declaration'
+    | 'lexical_alias_declaration'
+    | 'deterministic_reaching_assignment';
+  lexicalScopeChain?: LexicalScopeFact[];
+  bindingScopeIndex?: number;
+  scopeChainTotal: number;
+  scopeChainShown: number;
+  scopeChainOmitted: number;
+  reason?: ServiceBindingReferenceReason;
+}
+export type HandlerReferenceStatus =
+  | 'role_required'
+  | 'unsupported_inline'
+  | 'unsupported_wrapper'
+  | 'unsupported_reference_shape'
+  | 'missing_argument';
 export interface OutboundCallFact {
   callType: CallType;
   sourceSymbolQualifiedName?: string;
@@ -178,6 +233,7 @@ export interface OutboundCallFact {
   sourceLine: number;
   callSiteStartOffset?: number;
   callSiteEndOffset?: number;
+  serviceBindingReference?: ServiceBindingReference;
   confidence: number;
   unresolvedReason?: string;
   evidence?: Record<string, unknown>;

package/src/utils/001-placeholders.ts

@@ -1,26 +1,80 @@
+import ts from 'typescript';
+
 export interface PlaceholderSpan {
   readonly start: number;
   readonly end: number;
   readonly key: string;
 }
 
-export function scanPlaceholders(value: string | undefined): readonly PlaceholderSpan[] {
+export type PlaceholderScanReason =
+  | 'placeholder_expression_empty'
+  | 'placeholder_delimiter_mismatch'
+  | 'placeholder_token_unterminated'
+  | 'placeholder_unterminated';
+
+export interface PlaceholderScanResult {
+  readonly status: 'balanced' | 'malformed';
+  readonly spans: readonly PlaceholderSpan[];
+  readonly reason?: PlaceholderScanReason;
+  readonly failureOffset?: number;
+}
+
+type Delimiter = 'brace' | 'bracket' | 'paren' | 'template';
+
+interface PlaceholderMatch {
+  readonly span?: PlaceholderSpan;
+  readonly reason?: PlaceholderScanReason;
+  readonly failureOffset?: number;
+}
+
+const expressionEndTokens = new Set<ts.SyntaxKind>([
+  ts.SyntaxKind.Identifier,
+  ts.SyntaxKind.PrivateIdentifier,
+  ts.SyntaxKind.NumericLiteral,
+  ts.SyntaxKind.BigIntLiteral,
+  ts.SyntaxKind.StringLiteral,
+  ts.SyntaxKind.RegularExpressionLiteral,
+  ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+  ts.SyntaxKind.TemplateTail,
+  ts.SyntaxKind.TrueKeyword,
+  ts.SyntaxKind.FalseKeyword,
+  ts.SyntaxKind.NullKeyword,
+  ts.SyntaxKind.ThisKeyword,
+  ts.SyntaxKind.SuperKeyword,
+  ts.SyntaxKind.CloseBraceToken,
+  ts.SyntaxKind.CloseBracketToken,
+  ts.SyntaxKind.CloseParenToken,
+  ts.SyntaxKind.PlusPlusToken,
+  ts.SyntaxKind.MinusMinusToken,
+]);
+
+export function scanPlaceholderStructure(
+  value: string | undefined,
+): PlaceholderScanResult {
   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;
+    const match = scanPlaceholderAt(input, start);
+    if (!match.span) {
+      return {
+        status: 'malformed', spans: [], reason: match.reason,
+        failureOffset: match.failureOffset,
+      };
+    }
+    spans.push(match.span);
+    cursor = match.span.end;
   }
-  return spans;
+  return { status: 'balanced', spans };
+}
+
+export function scanPlaceholders(
+  value: string | undefined,
+): readonly PlaceholderSpan[] {
+  const result = scanPlaceholderStructure(value);
+  return result.status === 'balanced' ? result.spans : [];
 }
 
 export function extractPlaceholderKeys(value: string | undefined): string[] {
@@ -28,3 +82,127 @@ export function extractPlaceholderKeys(value: string | undefined): string[] {
     .map((span) => span.key.trim())
     .filter(Boolean);
 }
+
+function scanPlaceholderAt(input: string, start: number): PlaceholderMatch {
+  const bodyOffset = start + 2;
+  if (input.indexOf('}', bodyOffset) < 0)
+    return { reason: 'placeholder_unterminated', failureOffset: start };
+  const scanner = ts.createScanner(
+    ts.ScriptTarget.Latest,
+    false,
+    ts.LanguageVariant.Standard,
+    input.slice(bodyOffset),
+  );
+  const delimiters: Delimiter[] = [];
+  let previousEndsExpression = false;
+  while (true) {
+    const scanned = scanToken(scanner, previousEndsExpression);
+    if (scanner.isUnterminated())
+      return failedMatch('placeholder_token_unterminated', bodyOffset, scanner);
+    if (scanned === ts.SyntaxKind.EndOfFileToken)
+      return failedMatch('placeholder_unterminated', bodyOffset, scanner);
+    if (isTrivia(scanned)) continue;
+    const result = consumeDelimiter(scanner, scanned, delimiters);
+    if (result.reason)
+      return failedMatch(result.reason, bodyOffset, scanner);
+    if (result.closed) {
+      const end = bodyOffset + scanner.getTextPos();
+      const key = input.slice(bodyOffset, end - 1);
+      return key.trim()
+        ? { span: { start, end, key } }
+        : { reason: 'placeholder_expression_empty', failureOffset: start };
+    }
+    previousEndsExpression = tokenEndsExpression(
+      result.token, previousEndsExpression,
+    );
+  }
+}
+
+function scanToken(
+  scanner: ts.Scanner,
+  previousEndsExpression: boolean,
+): ts.SyntaxKind {
+  const token = scanner.scan();
+  if ((token === ts.SyntaxKind.SlashToken
+      || token === ts.SyntaxKind.SlashEqualsToken)
+    && !previousEndsExpression)
+    return scanner.reScanSlashToken();
+  return token;
+}
+
+function consumeDelimiter(
+  scanner: ts.Scanner,
+  token: ts.SyntaxKind,
+  stack: Delimiter[],
+): { token: ts.SyntaxKind; closed?: boolean; reason?: PlaceholderScanReason } {
+  if (token === ts.SyntaxKind.TemplateHead) stack.push('template');
+  else if (token === ts.SyntaxKind.OpenBraceToken) stack.push('brace');
+  else if (token === ts.SyntaxKind.OpenBracketToken) stack.push('bracket');
+  else if (token === ts.SyntaxKind.OpenParenToken) stack.push('paren');
+  else if (token === ts.SyntaxKind.CloseBracketToken)
+    return closeDelimiter(token, stack, 'bracket');
+  else if (token === ts.SyntaxKind.CloseParenToken)
+    return closeDelimiter(token, stack, 'paren');
+  else if (token === ts.SyntaxKind.CloseBraceToken)
+    return closeBrace(scanner, stack);
+  return { token };
+}
+
+function closeDelimiter(
+  token: ts.SyntaxKind,
+  stack: Delimiter[],
+  expected: Delimiter,
+): { token: ts.SyntaxKind; reason?: PlaceholderScanReason } {
+  if (stack.at(-1) !== expected)
+    return { token, reason: 'placeholder_delimiter_mismatch' };
+  stack.pop();
+  return { token };
+}
+
+function closeBrace(
+  scanner: ts.Scanner,
+  stack: Delimiter[],
+): { token: ts.SyntaxKind; closed?: boolean; reason?: PlaceholderScanReason } {
+  const current = stack.at(-1);
+  if (!current) return { token: ts.SyntaxKind.CloseBraceToken, closed: true };
+  if (current === 'brace') {
+    stack.pop();
+    return { token: ts.SyntaxKind.CloseBraceToken };
+  }
+  if (current !== 'template')
+    return {
+      token: ts.SyntaxKind.CloseBraceToken,
+      reason: 'placeholder_delimiter_mismatch',
+    };
+  const token = scanner.reScanTemplateToken(false);
+  if (token === ts.SyntaxKind.TemplateTail) stack.pop();
+  if (token !== ts.SyntaxKind.TemplateTail
+    && token !== ts.SyntaxKind.TemplateMiddle)
+    return { token, reason: 'placeholder_token_unterminated' };
+  return { token };
+}
+
+function failedMatch(
+  reason: PlaceholderScanReason,
+  bodyOffset: number,
+  scanner: ts.Scanner,
+): PlaceholderMatch {
+  return {
+    reason,
+    failureOffset: bodyOffset + scanner.getTokenPos(),
+  };
+}
+
+function tokenEndsExpression(
+  token: ts.SyntaxKind,
+  previousEndsExpression: boolean,
+): boolean {
+  if (token === ts.SyntaxKind.ExclamationToken)
+    return previousEndsExpression;
+  return expressionEndTokens.has(token);
+}
+
+function isTrivia(token: ts.SyntaxKind): boolean {
+  return token >= ts.SyntaxKind.FirstTriviaToken
+    && token <= ts.SyntaxKind.LastTriviaToken;
+}

package/src/version.ts

@@ -1,4 +1,4 @@
 import packageJson from '../package.json' with { type: 'json' };
 
 export const VERSION = packageJson.version;
-export const ANALYZER_VERSION = '0.1.66-facts.1';
+export const ANALYZER_VERSION = '0.1.68-facts.1';