@saptools/service-flow 0.1.36 → 0.1.38

package/src/parsers/cds-parser.ts

@@ -0,0 +1,147 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { CdsOperationFact, CdsServiceFact } from '../types.js';
+import { ensureLeadingSlash, normalizePath } from '../utils/path-utils.js';
+
+function lineOf(text: string, index: number): number {
+  return text.slice(0, index).split('\n').length;
+}
+
+function maskCommentsAndStrings(text: string): string {
+  let out = '';
+  let mode: 'code' | 'line' | 'block' | 'single' | 'double' | 'template' =
+    'code';
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i] ?? '';
+    const n = text[i + 1] ?? '';
+    if (mode === 'code' && c === '/' && n === '/') {
+      mode = 'line';
+      out += '  ';
+      i += 1;
+      continue;
+    }
+    if (mode === 'code' && c === '/' && n === '*') {
+      mode = 'block';
+      out += '  ';
+      i += 1;
+      continue;
+    }
+    if (mode === 'line' && c === '\n') mode = 'code';
+    if (mode === 'block' && c === '*' && n === '/') {
+      mode = 'code';
+      out += '  ';
+      i += 1;
+      continue;
+    }
+    if (mode === 'code' && (c === "'" || c === '"' || c === '`')) {
+      mode = c === "'" ? 'single' : c === '"' ? 'double' : 'template';
+      out += ' ';
+      continue;
+    }
+    if ((mode === 'single' && c === "'") || (mode === 'double' && c === '"') || (mode === 'template' && c === '`'))
+      mode = 'code';
+    out += mode === 'code' || c === '\n' ? c : ' ';
+  }
+  return out;
+}
+
+function readAnnotation(text: string, index: number): { end: number; raw: string } | undefined {
+  if (text[index] !== '@') return undefined;
+  let i = index + 1;
+  while (/\s/.test(text[i] ?? '')) i += 1;
+  if (text[i] !== '(') return undefined;
+  let depth = 0;
+  for (; i < text.length; i += 1) {
+    if (text[i] === '(') depth += 1;
+    if (text[i] === ')') depth -= 1;
+    if (depth === 0) return { end: i + 1, raw: text.slice(index, i + 1) };
+  }
+  return undefined;
+}
+
+function collectAnnotations(text: string, index: number): { end: number; raw: string } {
+  let i = index;
+  let raw = '';
+  while (i < text.length) {
+    while (/\s/.test(text[i] ?? '')) i += 1;
+    const annotation = readAnnotation(text, i);
+    if (!annotation) break;
+    raw += annotation.raw;
+    i = annotation.end;
+  }
+  return { end: i, raw };
+}
+
+function pathAnnotation(raw: string): string | undefined {
+  return /path\s*:\s*['"]([^'"]+)['"]/s.exec(raw)?.[1];
+}
+
+function matchingBrace(text: string, open: number): number {
+  let depth = 0;
+  for (let i = open; i < text.length; i += 1) {
+    if (text[i] === '{') depth += 1;
+    if (text[i] === '}') depth -= 1;
+    if (depth === 0) return i;
+  }
+  return text.length - 1;
+}
+
+function operationsFromBody(text: string, maskedBody: string, bodyOffset: number, filePath: string): CdsOperationFact[] {
+  return [...maskedBody.matchAll(/\b(action|function|event)\s+(\w+)\s*(?:\(([^)]*)\))?\s*(?:returns\s+([^;{]+))?/g)].map((m) => ({
+    operationType: (m[1] as 'action' | 'function' | 'event') ?? 'action',
+    operationName: m[2] ?? 'unknown',
+    operationPath: ensureLeadingSlash(m[2] ?? 'unknown'),
+    paramsJson: JSON.stringify((m[3] ?? '').split(',').map((part) => part.trim()).filter(Boolean)),
+    returnType: m[4]?.trim(),
+    sourceFile: normalizePath(filePath),
+    sourceLine: lineOf(text, bodyOffset + (m.index ?? 0))
+  }));
+}
+
+export async function parseCdsFile(repoPath: string, filePath: string): Promise<CdsServiceFact[]> {
+  const absolute = path.join(repoPath, filePath);
+  const text = await fs.readFile(absolute, 'utf8');
+  const masked = maskCommentsAndStrings(text);
+  const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
+  const services: CdsServiceFact[] = [];
+  const pendingAnnotations: Array<{ end: number; raw: string }> = [];
+  for (const a of masked.matchAll(/@\s*\(/g)) {
+    const annotation = collectAnnotations(masked, a.index ?? 0);
+    pendingAnnotations.push(annotation);
+  }
+  const serviceRegex = /\b(extend\s+)?service\s+([\w.]+)\b/g;
+  let match: RegExpExecArray | null;
+  while ((match = serviceRegex.exec(masked))) {
+    const afterName = collectAnnotations(masked, serviceRegex.lastIndex);
+    const open = masked.indexOf('{', afterName.end);
+    if (open === -1) continue;
+    const matchIndex = match.index;
+    const prefix = pendingAnnotations
+      .filter((a) => a.end <= matchIndex && matchIndex - a.end < 8)
+      .map((a) => a.raw)
+      .join('');
+    const annotations = `${prefix}${afterName.raw}`;
+    const end = matchingBrace(masked, open);
+    const body = masked.slice(open + 1, end);
+    const name = match[2] ?? 'UnknownService';
+    const serviceName = name.split('.').pop() ?? name;
+    const servicePath = ensureLeadingSlash(pathAnnotation(annotations) ?? serviceName);
+    services.push({
+      namespace,
+      serviceName,
+      qualifiedName: name.includes('.') ? name : namespace ? `${namespace}.${name}` : name,
+      servicePath,
+      isExtend: Boolean(match[1]),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf(text, match.index),
+      operations: operationsFromBody(text, body, open + 1, filePath)
+    });
+    serviceRegex.lastIndex = end + 1;
+  }
+  const baseOps = new Map(services.filter((s) => !s.isExtend).map((s) => [s.qualifiedName, s.operations]));
+  for (const service of services.filter((s) => s.isExtend && s.operations.length === 0)) {
+    const inherited = baseOps.get(service.qualifiedName) ?? baseOps.get(service.serviceName);
+    if (inherited) service.operations = inherited.map((op) => ({ ...op, sourceFile: service.sourceFile, sourceLine: service.sourceLine }));
+  }
+  return services;
+}

package/src/parsers/decorator-parser.ts

@@ -0,0 +1,76 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import type { HandlerClassFact } from '../types.js';
+import { createSourceFile } from './ts-project.js';
+import { normalizePath, stripQuotes } from '../utils/path-utils.js';
+function line(sf: ts.SourceFile, pos: number): number {
+  return sf.getLineAndCharacterOfPosition(pos).line + 1;
+}
+function decs(node: ts.Node): ts.Decorator[] {
+  return ts.canHaveDecorators(node) ? [...(ts.getDecorators(node) ?? [])] : [];
+}
+function callName(d: ts.Decorator): string {
+  const e = d.expression;
+  return ts.isCallExpression(e) ? e.expression.getText() : e.getText();
+}
+function firstArg(d: ts.Decorator): string {
+  const e = d.expression;
+  return ts.isCallExpression(e) && e.arguments[0]
+    ? e.arguments[0].getText()
+    : '';
+}
+export async function parseDecorators(
+  repoPath: string,
+  filePath: string
+): Promise<HandlerClassFact[]> {
+  const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
+  const sf = createSourceFile(filePath, text);
+  const constants = new Map<string, string>();
+  const handlers: HandlerClassFact[] = [];
+  function visit(node: ts.Node): void {
+    if (
+      ts.isVariableDeclaration(node) &&
+      ts.isIdentifier(node.name) &&
+      node.initializer &&
+      ts.isStringLiteralLike(node.initializer)
+    )
+      constants.set(node.name.text, node.initializer.text);
+    if (ts.isClassDeclaration(node)) {
+      const className = node.name?.text ?? 'AnonymousHandler';
+      const hasHandler = decs(node).some((d) => callName(d) === 'Handler');
+      const methods = node.members.filter(ts.isMethodDeclaration).flatMap((m) =>
+        decs(m)
+          .filter((d) =>
+            ['Func', 'Action', 'On', 'Event'].includes(callName(d))
+          )
+          .map((d) => {
+            const raw = firstArg(d);
+            const value =
+              raw.startsWith('"') || raw.startsWith("'") || raw.startsWith('`')
+                ? stripQuotes(raw)
+                : (constants.get(raw) ??
+                  (raw.endsWith('.name') ? raw.split('.').at(-2) : undefined));
+            return {
+              methodName: m.name.getText(),
+              decoratorKind: callName(d),
+              decoratorValue: value,
+              decoratorRawExpression: raw,
+              sourceFile: normalizePath(filePath),
+              sourceLine: line(sf, m.getStart())
+            };
+          })
+      );
+      if (hasHandler || methods.length > 0)
+        handlers.push({
+          className,
+          sourceFile: normalizePath(filePath),
+          sourceLine: line(sf, node.getStart()),
+          methods
+        });
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sf);
+  return handlers;
+}

package/src/parsers/generated-constants-parser.ts

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { GeneratedConstantFact } from '../types.js';
+import { normalizePath, stripQuotes } from '../utils/path-utils.js';
+function lineOf(text: string, idx: number): number {
+  return text.slice(0, idx).split('\n').length;
+}
+export async function parseGeneratedConstants(
+  repoPath: string,
+  filePath: string
+): Promise<GeneratedConstantFact[]> {
+  const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
+  return [
+    ...text.matchAll(
+      /(?:export\s+)?(?:const|static\s+readonly)\s+(\w+)\s*=\s*(['"])([^'"]+)\2/g
+    )
+  ].map((m) => ({
+    name: m[1] ?? 'constant',
+    value: stripQuotes(m[3] ?? ''),
+    sourceFile: normalizePath(filePath),
+    sourceLine: lineOf(text, m.index ?? 0)
+  }));
+}

package/src/parsers/handler-registration-parser.ts

@@ -0,0 +1,177 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import type { HandlerRegistrationFact } from '../types.js';
+import { normalizePath } from '../utils/path-utils.js';
+
+interface ImportEvidence { importedName: string; source: string }
+interface ClassEvidence { className: string; importSource?: string }
+interface FileExports { arrays: Map<string, ClassEvidence[]>; defaultArray?: ClassEvidence[]; aliases: Map<string, string> }
+
+const MAX_EXPORT_DEPTH = 5;
+
+function lineOf(sourceFile: ts.SourceFile, node: ts.Node): number {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function isRelative(source: string): boolean {
+  return source.startsWith('./') || source.startsWith('../');
+}
+function sourceText(node: ts.PropertyName, sourceFile: ts.SourceFile): string | undefined {
+  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return node.text;
+  return node.getText(sourceFile);
+}
+function importSourceFor(identifier: string, imports: Map<string, ImportEvidence>): string | undefined {
+  const evidence = imports.get(identifier);
+  return evidence ? `${evidence.source}#${evidence.importedName}` : undefined;
+}
+
+export async function parseHandlerRegistrations(repoPath: string, filePath: string): Promise<HandlerRegistrationFact[]> {
+  const absolutePath = path.join(repoPath, filePath);
+  const text = await fs.readFile(absolutePath, 'utf8');
+  const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const imports = collectImports(sourceFile);
+  const localArrays = collectLocalArrays(sourceFile, imports, new Map(), repoPath, filePath);
+  const out: HandlerRegistrationFact[] = [];
+
+  function emitFromExpression(expression: ts.Expression, call: ts.CallExpression): void {
+    const classes = resolveArrayExpression(expression, localArrays, imports, repoPath, filePath, new Set());
+    for (const cls of classes) {
+      out.push({
+        className: cls.className,
+        importSource: cls.importSource,
+        registrationFile: normalizePath(filePath),
+        registrationLine: lineOf(sourceFile, call),
+        registrationKind: 'combined-handler-class',
+        confidence: 0.95,
+      });
+    }
+    if (classes.length === 0) {
+      out.push({
+        registrationFile: normalizePath(filePath),
+        registrationLine: lineOf(sourceFile, call),
+        registrationKind: 'combined-handler',
+        confidence: 0.75,
+      });
+    }
+  }
+
+  function visit(node: ts.Node): void {
+    if (ts.isCallExpression(node) && isRegistrationCall(node)) {
+      const handlerExpr = handlerExpression(node, sourceFile);
+      if (handlerExpr) emitFromExpression(handlerExpr, node);
+      else out.push({ registrationFile: normalizePath(filePath), registrationLine: lineOf(sourceFile, node), registrationKind: 'combined-handler', confidence: 0.75 });
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return out;
+}
+
+function isRegistrationCall(call: ts.CallExpression): boolean {
+  const text = call.expression.getText();
+  return text.endsWith('createCombinedHandler') || text.endsWith('srv.prepend') || text.endsWith('cds.serve');
+}
+function handlerExpression(call: ts.CallExpression, sourceFile: ts.SourceFile): ts.Expression | undefined {
+  for (const arg of call.arguments) {
+    if (!ts.isObjectLiteralExpression(arg)) continue;
+    for (const prop of arg.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue;
+      if (sourceText(prop.name, sourceFile) === 'handler') return prop.initializer;
+    }
+  }
+  return undefined;
+}
+function collectImports(sourceFile: ts.SourceFile): Map<string, ImportEvidence> {
+  const imports = new Map<string, ImportEvidence>();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const source = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (!clause) continue;
+    if (clause.name) imports.set(clause.name.text, { importedName: 'default', source });
+    const named = clause.namedBindings;
+    if (named && ts.isNamedImports(named)) {
+      for (const element of named.elements) imports.set(element.name.text, { importedName: element.propertyName?.text ?? element.name.text, source });
+    }
+    if (named && ts.isNamespaceImport(named)) imports.set(named.name.text, { importedName: '*', source });
+  }
+  return imports;
+}
+function collectLocalArrays(sourceFile: ts.SourceFile, imports: Map<string, ImportEvidence>, seed: Map<string, ClassEvidence[]>, repoPath = '', fromFile = ''): Map<string, ClassEvidence[]> {
+  const arrays = new Map(seed);
+  for (const statement of sourceFile.statements) {
+    if (ts.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.initializer && ts.isArrayLiteralExpression(decl.initializer)) {
+          arrays.set(decl.name.text, resolveArrayLiteral(decl.initializer, arrays, imports, repoPath, fromFile, new Set()));
+        }
+      }
+    }
+  }
+  return arrays;
+}
+function resolveArrayExpression(expr: ts.Expression, arrays: Map<string, ClassEvidence[]>, imports: Map<string, ImportEvidence>, repoPath: string, fromFile: string, seen: Set<string>): ClassEvidence[] {
+  if (ts.isArrayLiteralExpression(expr)) return resolveArrayLiteral(expr, arrays, imports, repoPath, fromFile, seen);
+  if (ts.isIdentifier(expr)) {
+    const local = arrays.get(expr.text);
+    if (local) return local;
+    const evidence = imports.get(expr.text);
+    if (evidence && isRelative(evidence.source)) return resolveImportedArray(repoPath, fromFile, evidence, seen);
+    if (evidence) return [{ className: evidence.importedName === 'default' ? expr.text : evidence.importedName, importSource: `${evidence.source}#${evidence.importedName}` }];
+  }
+  return [];
+}
+function resolveArrayLiteral(array: ts.ArrayLiteralExpression, arrays: Map<string, ClassEvidence[]>, imports: Map<string, ImportEvidence>, repoPath: string, fromFile: string, seen: Set<string>): ClassEvidence[] {
+  const out: ClassEvidence[] = [];
+  for (const element of array.elements) {
+    if (ts.isSpreadElement(element)) out.push(...resolveArrayExpression(element.expression, arrays, imports, repoPath, fromFile, seen));
+    else if (ts.isIdentifier(element)) out.push({ className: element.text, importSource: importSourceFor(element.text, imports) });
+  }
+  return out;
+}
+function resolveImportedArray(repoPath: string, fromFile: string, evidence: ImportEvidence, seen: Set<string>): ClassEvidence[] {
+  const moduleFile = resolveRelativeModule(repoPath, fromFile, evidence.source);
+  if (!moduleFile) return [];
+  const key = `${moduleFile}:${evidence.importedName}`;
+  if (seen.has(key) || seen.size > MAX_EXPORT_DEPTH) return [];
+  seen.add(key);
+  const exports = readExports(repoPath, moduleFile, seen);
+  if (evidence.importedName === 'default') return exports.defaultArray ?? [];
+  return exports.arrays.get(evidence.importedName) ?? exports.arrays.get(exports.aliases.get(evidence.importedName) ?? evidence.importedName) ?? [];
+}
+function resolveRelativeModule(repoPath: string, fromFile: string, specifier: string): string | undefined {
+  const base = path.resolve(repoPath, path.dirname(fromFile), specifier);
+  for (const candidate of [base, `${base}.ts`, `${base}.js`, path.join(base, 'index.ts'), path.join(base, 'index.js')]) {
+    try {
+      const stat = fsSync.statSync(candidate);
+      if (stat.isFile()) return normalizePath(path.relative(repoPath, candidate));
+    } catch { /* ignore missing candidate */ }
+  }
+  return undefined;
+}
+function readExports(repoPath: string, filePath: string, seen: Set<string>): FileExports {
+  const absolute = path.join(repoPath, filePath);
+  let text: string;
+  try { text = fsSync.readFileSync(absolute, 'utf8'); } catch { return { arrays: new Map(), aliases: new Map() }; }
+  const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const imports = collectImports(sourceFile);
+  const arrays = collectLocalArrays(sourceFile, imports, new Map(), repoPath, filePath);
+  const aliases = new Map<string, string>();
+  let defaultArray: ClassEvidence[] | undefined;
+  for (const statement of sourceFile.statements) {
+    if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)) defaultArray = arrays.get(statement.expression.text);
+    if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+      const module = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : undefined;
+      for (const element of statement.exportClause.elements) {
+        const local = element.propertyName?.text ?? element.name.text;
+        aliases.set(element.name.text, local);
+        if (module && isRelative(module)) {
+          const imported = resolveImportedArray(repoPath, filePath, { source: module, importedName: local }, seen);
+          if (imported.length > 0) arrays.set(element.name.text, imported);
+        }
+      }
+    }
+  }
+  return { arrays, defaultArray, aliases };
+}