@living-architecture/riviere-extract-ts 0.2.2 → 0.2.4

package/dist/domain/connection-detection/call-graph/build-call-graph.d.ts

@@ -0,0 +1,7 @@
+import { type Project } from 'ts-morph';
+import type { EnrichedComponent } from '../../value-extraction/enrich-components';
+import type { ComponentIndex } from '../component-index';
+import type { ExtractedLink } from '../extracted-link';
+import type { CallGraphOptions } from './call-graph-types';
+export declare function buildCallGraph(project: Project, components: readonly EnrichedComponent[], componentIndex: ComponentIndex, options: CallGraphOptions): ExtractedLink[];
+//# sourceMappingURL=build-call-graph.d.ts.map

package/dist/domain/connection-detection/call-graph/build-call-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-call-graph.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/build-call-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,OAAO,EAEb,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EACV,gBAAgB,EACjB,MAAM,oBAAoB,CAAA;AAyG3B,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,gBAAgB,GACxB,aAAa,EAAE,CAgBjB"}

package/dist/domain/connection-detection/call-graph/build-call-graph.js

@@ -0,0 +1,77 @@
+import { Node, SyntaxKind, } from 'ts-morph';
+import { componentIdentity } from './call-graph-types';
+import { findClassInProject, traceCallsInBody } from './trace-calls';
+import { deduplicateLinks } from './deduplicate-links';
+import { resolveCallExpressionReceiverType } from './type-resolver';
+import { getCalledMethodName, resolveTypeThroughInterface, findMethodInProject, } from './call-graph-shared';
+function processCallExpression(callExpr, component, methodName, project, componentIndex, rawLinks, uncertainLinks, options) {
+    if (!Node.isPropertyAccessExpression(callExpr.getExpression())) {
+        return;
+    }
+    const sourceFile = callExpr.getSourceFile();
+    const typeResult = resolveCallExpressionReceiverType(callExpr, sourceFile, { strict: options.strict, });
+    const currentCallSite = {
+        filePath: component.location.file,
+        lineNumber: callExpr.getStartLineNumber(),
+        methodName,
+    };
+    if (!typeResult.resolved) {
+        uncertainLinks.push({
+            source: component,
+            reason: typeResult.reason,
+            callSite: currentCallSite,
+        });
+        return;
+    }
+    const typeName = typeResult.typeName;
+    const calledMethodName = getCalledMethodName(callExpr);
+    const { component: targetComponent, resolvedTypeName, uncertain, } = resolveTypeThroughInterface(typeName, project, componentIndex, options);
+    if (targetComponent !== undefined) {
+        if (componentIdentity(component) !== componentIdentity(targetComponent)) {
+            rawLinks.push({
+                source: component,
+                target: targetComponent,
+                callSite: currentCallSite,
+            });
+        }
+        return;
+    }
+    traceNonComponent(project, componentIndex, component, resolvedTypeName ?? typeName, calledMethodName, currentCallSite, rawLinks, uncertainLinks, uncertain, options);
+}
+function processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options) {
+    const methodName = method.getName();
+    const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+        processCallExpression(callExpr, component, methodName, project, componentIndex, rawLinks, uncertainLinks, options);
+    }
+}
+export function buildCallGraph(project, components, componentIndex, options) {
+    const rawLinks = [];
+    const uncertainLinks = [];
+    for (const component of components) {
+        const classDecl = findClassInProject(project, component);
+        if (classDecl === undefined) {
+            continue;
+        }
+        for (const method of classDecl.getMethods()) {
+            processMethod(method, component, project, componentIndex, rawLinks, uncertainLinks, options);
+        }
+    }
+    return deduplicateLinks(rawLinks, uncertainLinks);
+}
+function traceNonComponent(project, componentIndex, source, typeName, calledMethodName, callSite, rawLinks, uncertainLinks, interfaceUncertainty, options) {
+    const visited = new Set();
+    visited.add(`${typeName}.${calledMethodName}`);
+    const { method, classFound } = findMethodInProject(project, typeName, calledMethodName);
+    if (method !== undefined) {
+        traceCallsInBody(method, project, componentIndex, source, callSite, visited, rawLinks, uncertainLinks, options);
+        return;
+    }
+    if (!classFound && interfaceUncertainty !== undefined) {
+        uncertainLinks.push({
+            source,
+            reason: interfaceUncertainty,
+            callSite,
+        });
+    }
+}

package/dist/domain/connection-detection/call-graph/call-graph-fixtures.d.ts

@@ -0,0 +1,8 @@
+import { Project } from 'ts-morph';
+import type { EnrichedComponent } from '../../value-extraction/enrich-components';
+import type { CallGraphOptions } from './call-graph-types';
+export declare const sharedProject: Project;
+export declare function nextFile(content: string): string;
+export declare function buildComponent(name: string, file: string, line: number, overrides?: Partial<EnrichedComponent>): EnrichedComponent;
+export declare function defaultOptions(): CallGraphOptions;
+//# sourceMappingURL=call-graph-fixtures.d.ts.map

package/dist/domain/connection-detection/call-graph/call-graph-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-graph-fixtures.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/call-graph-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,eAAO,MAAM,aAAa,SAOxB,CAAA;AAIF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKhD;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,OAAO,CAAC,iBAAiB,CAAM,GACzC,iBAAiB,CAYnB;AAED,wBAAgB,cAAc,IAAI,gBAAgB,CAKjD"}

package/dist/domain/connection-detection/call-graph/call-graph-fixtures.js

@@ -0,0 +1,35 @@
+import { Project } from 'ts-morph';
+export const sharedProject = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+        strict: true,
+        target: 99,
+        module: 99,
+    },
+});
+const counter = { value: 0 };
+export function nextFile(content) {
+    counter.value++;
+    const filePath = `/src/test-call-graph-${counter.value}.ts`;
+    sharedProject.createSourceFile(filePath, content);
+    return filePath;
+}
+export function buildComponent(name, file, line, overrides = {}) {
+    return {
+        type: 'useCase',
+        name,
+        location: {
+            file,
+            line,
+        },
+        domain: 'orders',
+        metadata: {},
+        ...overrides,
+    };
+}
+export function defaultOptions() {
+    return {
+        strict: false,
+        sourceFilePaths: sharedProject.getSourceFiles().map((sf) => sf.getFilePath()),
+    };
+}

package/dist/domain/connection-detection/call-graph/call-graph-shared.d.ts

@@ -0,0 +1,17 @@
+import { type CallExpression, type MethodDeclaration, type Project } from 'ts-morph';
+import type { EnrichedComponent } from '../../value-extraction/enrich-components';
+import type { ComponentIndex } from '../component-index';
+import type { CallGraphOptions } from './call-graph-types';
+export interface InterfaceResolutionOutcome {
+    component: EnrichedComponent | undefined;
+    resolvedTypeName: string | undefined;
+    uncertain: string | undefined;
+}
+export interface MethodLookup {
+    method: MethodDeclaration | undefined;
+    classFound: boolean;
+}
+export declare function getCalledMethodName(callExpr: CallExpression): string;
+export declare function resolveTypeThroughInterface(typeName: string, project: Project, componentIndex: ComponentIndex, options: CallGraphOptions): InterfaceResolutionOutcome;
+export declare function findMethodInProject(project: Project, typeName: string, methodName: string): MethodLookup;
+//# sourceMappingURL=call-graph-shared.d.ts.map

package/dist/domain/connection-detection/call-graph/call-graph-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-graph-shared.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/call-graph-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAAE,KAAK,iBAAiB,EAAE,KAAK,OAAO,EAC1D,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAG1D,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACxC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAA;IACrC,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAGpE;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,gBAAgB,GACxB,0BAA0B,CAwB5B;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,YAAY,CAgBd"}

package/dist/domain/connection-detection/call-graph/call-graph-shared.js

@@ -0,0 +1,46 @@
+import { SyntaxKind } from 'ts-morph';
+import { resolveInterface } from '../interface-resolution/resolve-interface';
+export function getCalledMethodName(callExpr) {
+    const expression = callExpr.getExpression();
+    return expression.asKindOrThrow(SyntaxKind.PropertyAccessExpression).getName();
+}
+export function resolveTypeThroughInterface(typeName, project, componentIndex, options) {
+    const component = componentIndex.getComponentByTypeName(typeName);
+    if (component !== undefined) {
+        return {
+            component,
+            resolvedTypeName: undefined,
+            uncertain: undefined,
+        };
+    }
+    const interfaceResult = resolveInterface(typeName, project, options.sourceFilePaths, { strict: options.strict, });
+    if (interfaceResult.resolved) {
+        return {
+            component: componentIndex.getComponentByTypeName(interfaceResult.typeName),
+            resolvedTypeName: interfaceResult.typeName,
+            uncertain: undefined,
+        };
+    }
+    return {
+        component: undefined,
+        resolvedTypeName: undefined,
+        uncertain: interfaceResult.typeDefinedInSource ? interfaceResult.reason : undefined,
+    };
+}
+export function findMethodInProject(project, typeName, methodName) {
+    for (const sourceFile of project.getSourceFiles()) {
+        for (const classDecl of sourceFile.getClasses()) {
+            if (classDecl.getName() !== typeName) {
+                continue;
+            }
+            return {
+                method: classDecl.getMethod(methodName),
+                classFound: true,
+            };
+        }
+    }
+    return {
+        method: undefined,
+        classFound: false,
+    };
+}

package/dist/domain/connection-detection/call-graph/call-graph-types.d.ts

@@ -0,0 +1,23 @@
+import type { EnrichedComponent } from '../../value-extraction/enrich-components';
+export interface CallGraphOptions {
+    strict: boolean;
+    sourceFilePaths: string[];
+}
+export interface CallSite {
+    filePath: string;
+    lineNumber: number;
+    methodName: string;
+}
+export interface RawLink {
+    source: EnrichedComponent;
+    target: EnrichedComponent;
+    callSite: CallSite;
+}
+export interface UncertainRawLink {
+    source: EnrichedComponent;
+    reason: string;
+    callSite: CallSite;
+}
+export declare function componentIdentity(component: EnrichedComponent): string;
+export declare function stripGenericArgs(typeName: string): string;
+//# sourceMappingURL=call-graph-types.d.ts.map

package/dist/domain/connection-detection/call-graph/call-graph-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-graph-types.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/call-graph-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AAEjF,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAA;IACf,eAAe,EAAE,MAAM,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,iBAAiB,CAAA;IACzB,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,QAAQ,CAAA;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,iBAAiB,CAAA;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,QAAQ,CAAA;CACnB;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,GAAG,MAAM,CAEtE;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMzD"}

package/dist/domain/connection-detection/call-graph/call-graph-types.js

@@ -0,0 +1,10 @@
+export function componentIdentity(component) {
+    return `${component.domain}:${component.type}:${component.name}`;
+}
+export function stripGenericArgs(typeName) {
+    const index = typeName.indexOf('<');
+    if (index === -1) {
+        return typeName;
+    }
+    return typeName.slice(0, index);
+}

package/dist/domain/connection-detection/call-graph/deduplicate-links.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractedLink } from '../extracted-link';
+import type { RawLink, UncertainRawLink } from './call-graph-types';
+export declare function deduplicateLinks(rawLinks: RawLink[], uncertainLinks: UncertainRawLink[], repository?: string): ExtractedLink[];
+//# sourceMappingURL=deduplicate-links.d.ts.map

package/dist/domain/connection-detection/call-graph/deduplicate-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicate-links.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/deduplicate-links.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EACV,OAAO,EAAE,gBAAgB,EAC1B,MAAM,oBAAoB,CAAA;AAwD3B,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,cAAc,EAAE,gBAAgB,EAAE,EAClC,UAAU,SAAK,GACd,aAAa,EAAE,CAkCjB"}

package/dist/domain/connection-detection/call-graph/deduplicate-links.js

@@ -0,0 +1,53 @@
+import { componentIdentity } from './call-graph-types';
+function linkKey(source, target, type) {
+    return `${source}|${target}|${type}`;
+}
+function buildExtractedLink(source, target, type, callSite, repository) {
+    return {
+        source,
+        target,
+        type,
+        sourceLocation: {
+            repository,
+            filePath: callSite.filePath,
+            lineNumber: callSite.lineNumber,
+            methodName: callSite.methodName,
+        },
+    };
+}
+function buildUncertainLink(source, reason, callSite, repository) {
+    return {
+        source,
+        target: '_unresolved',
+        type: 'sync',
+        _uncertain: reason,
+        sourceLocation: {
+            repository,
+            filePath: callSite.filePath,
+            lineNumber: callSite.lineNumber,
+            methodName: callSite.methodName,
+        },
+    };
+}
+export function deduplicateLinks(rawLinks, uncertainLinks, repository = '') {
+    const seen = new Map();
+    for (const raw of rawLinks) {
+        const sourceId = componentIdentity(raw.source);
+        const targetId = componentIdentity(raw.target);
+        const type = 'sync';
+        const key = linkKey(sourceId, targetId, type);
+        const existing = seen.get(key);
+        if (existing !== undefined) {
+            if (raw.callSite.lineNumber < existing.sourceLocation.lineNumber) {
+                seen.set(key, buildExtractedLink(sourceId, targetId, type, raw.callSite, repository));
+            }
+            continue;
+        }
+        seen.set(key, buildExtractedLink(sourceId, targetId, type, raw.callSite, repository));
+    }
+    const result = [...seen.values()];
+    for (const uncertain of uncertainLinks) {
+        result.push(buildUncertainLink(componentIdentity(uncertain.source), uncertain.reason, uncertain.callSite, repository));
+    }
+    return result;
+}

package/dist/domain/connection-detection/call-graph/trace-calls.d.ts

@@ -0,0 +1,7 @@
+import { type ClassDeclaration, type Project, type MethodDeclaration } from 'ts-morph';
+import type { ComponentIndex } from '../component-index';
+import type { EnrichedComponent } from '../../value-extraction/enrich-components';
+import type { CallGraphOptions, CallSite, RawLink, UncertainRawLink } from './call-graph-types';
+export declare function traceCallsInBody(body: MethodDeclaration, project: Project, componentIndex: ComponentIndex, sourceComponent: EnrichedComponent, originCallSite: CallSite, visited: Set<string>, results: RawLink[], uncertainResults: UncertainRawLink[], options: CallGraphOptions): void;
+export declare function findClassInProject(project: Project, component: EnrichedComponent): ClassDeclaration | undefined;
+//# sourceMappingURL=trace-calls.d.ts.map

package/dist/domain/connection-detection/call-graph/trace-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-calls.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/trace-calls.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAAE,KAAK,OAAO,EAAE,KAAK,iBAAiB,EAC5D,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAA;AACjF,OAAO,KAAK,EACV,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB,EACtD,MAAM,oBAAoB,CAAA;AAS3B,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,iBAAiB,EAClC,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EACpB,OAAO,EAAE,OAAO,EAAE,EAClB,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAiEN;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,iBAAiB,GAC3B,gBAAgB,GAAG,SAAS,CAM9B"}

package/dist/domain/connection-detection/call-graph/trace-calls.js

@@ -0,0 +1,51 @@
+import { SyntaxKind } from 'ts-morph';
+import { componentIdentity } from './call-graph-types';
+import { resolveCallExpressionReceiverType } from './type-resolver';
+import { getCalledMethodName, resolveTypeThroughInterface, findMethodInProject, } from './call-graph-shared';
+export function traceCallsInBody(body, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options) {
+    const callExpressions = body.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+        const sourceFile = callExpr.getSourceFile();
+        const typeResult = resolveCallExpressionReceiverType(callExpr, sourceFile, { strict: options.strict, });
+        if (!typeResult.resolved) {
+            continue;
+        }
+        const typeName = typeResult.typeName;
+        const calledMethodName = getCalledMethodName(callExpr);
+        const { component: targetComponent, resolvedTypeName, uncertain, } = resolveTypeThroughInterface(typeName, project, componentIndex, options);
+        if (targetComponent !== undefined) {
+            if (componentIdentity(sourceComponent) !== componentIdentity(targetComponent)) {
+                results.push({
+                    source: sourceComponent,
+                    target: targetComponent,
+                    callSite: originCallSite,
+                });
+            }
+            continue;
+        }
+        const traceTypeName = resolvedTypeName ?? typeName;
+        const visitKey = `${traceTypeName}.${calledMethodName}`;
+        if (visited.has(visitKey)) {
+            continue;
+        }
+        visited.add(visitKey);
+        const { method: resolvedMethod, classFound } = findMethodInProject(project, traceTypeName, calledMethodName);
+        if (resolvedMethod !== undefined) {
+            traceCallsInBody(resolvedMethod, project, componentIndex, sourceComponent, originCallSite, visited, results, uncertainResults, options);
+        }
+        else if (!classFound && uncertain !== undefined) {
+            uncertainResults.push({
+                source: sourceComponent,
+                reason: uncertain,
+                callSite: originCallSite,
+            });
+        }
+    }
+}
+export function findClassInProject(project, component) {
+    const sourceFile = project.getSourceFile(component.location.file);
+    if (sourceFile === undefined) {
+        return undefined;
+    }
+    return sourceFile.getClasses().find((c) => c.getStartLineNumber() === component.location.line);
+}

package/dist/domain/connection-detection/call-graph/type-resolver-fixtures.d.ts

@@ -0,0 +1,10 @@
+import { Project, CallExpression } from 'ts-morph';
+export declare class CallExpressionNotFoundError extends Error {
+    constructor(scope: string, method: string);
+}
+export declare const sharedProject: Project;
+export declare function nextFile(content: string): string;
+export declare function getFirstCallExpression(filePath: string, className: string, methodName: string): CallExpression;
+export declare function getCallExpressionFromFunction(filePath: string, functionName: string): CallExpression;
+export declare function getCallExpressionByText(filePath: string, className: string, methodName: string, text: string): CallExpression;
+//# sourceMappingURL=type-resolver-fixtures.d.ts.map

package/dist/domain/connection-detection/call-graph/type-resolver-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-resolver-fixtures.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/type-resolver-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAAE,cAAc,EACxB,MAAM,UAAU,CAAA;AAEjB,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI1C;AAED,eAAO,MAAM,aAAa,SAOxB,CAAA;AAGF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKhD;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,cAAc,CAQhB;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,cAAc,CAOhB;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,cAAc,CAQhB"}

package/dist/domain/connection-detection/call-graph/type-resolver-fixtures.js

@@ -0,0 +1,51 @@
+import { Project, CallExpression, SyntaxKind } from 'ts-morph';
+export class CallExpressionNotFoundError extends Error {
+    constructor(scope, method) {
+        super(`No call expression found in ${scope}.${method}`);
+        this.name = 'CallExpressionNotFoundError';
+    }
+}
+export const sharedProject = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+        strict: true,
+        target: 99,
+        module: 99,
+    },
+});
+const counter = { value: 0 };
+export function nextFile(content) {
+    counter.value++;
+    const filePath = `/src/test-type-resolver-${counter.value}.ts`;
+    sharedProject.createSourceFile(filePath, content);
+    return filePath;
+}
+export function getFirstCallExpression(filePath, className, methodName) {
+    const sourceFile = sharedProject.getSourceFileOrThrow(filePath);
+    const classDecl = sourceFile.getClassOrThrow(className);
+    const method = classDecl.getMethodOrThrow(methodName);
+    const callExprs = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const [first] = callExprs;
+    if (!first)
+        throw new CallExpressionNotFoundError(className, methodName);
+    return first;
+}
+export function getCallExpressionFromFunction(filePath, functionName) {
+    const sourceFile = sharedProject.getSourceFileOrThrow(filePath);
+    const funcDecl = sourceFile.getFunctionOrThrow(functionName);
+    const callExprs = funcDecl.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const [first] = callExprs;
+    if (!first)
+        throw new CallExpressionNotFoundError('function', functionName);
+    return first;
+}
+export function getCallExpressionByText(filePath, className, methodName, text) {
+    const sourceFile = sharedProject.getSourceFileOrThrow(filePath);
+    const classDecl = sourceFile.getClassOrThrow(className);
+    const method = classDecl.getMethodOrThrow(methodName);
+    const callExprs = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+    const match = callExprs.find((c) => c.getText().includes(text));
+    if (!match)
+        throw new CallExpressionNotFoundError(className, methodName);
+    return match;
+}

package/dist/domain/connection-detection/call-graph/type-resolver.d.ts

@@ -0,0 +1,15 @@
+import { CallExpression, SourceFile } from 'ts-morph';
+interface TypeResolutionSuccess {
+    resolved: true;
+    typeName: string;
+}
+interface TypeResolutionUncertain {
+    resolved: false;
+    reason: string;
+}
+export type TypeResolution = TypeResolutionSuccess | TypeResolutionUncertain;
+export declare function resolveCallExpressionReceiverType(callExpression: CallExpression, sourceFile: SourceFile, options: {
+    strict: boolean;
+}): TypeResolution;
+export {};
+//# sourceMappingURL=type-resolver.d.ts.map

package/dist/domain/connection-detection/call-graph/type-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-resolver.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/call-graph/type-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAAE,UAAU,EAC3B,MAAM,UAAU,CAAA;AAIjB,UAAU,qBAAqB;IAC7B,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,KAAK,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,MAAM,cAAc,GAAG,qBAAqB,GAAG,uBAAuB,CAAA;AA2H5E,wBAAgB,iCAAiC,CAC/C,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAC3B,cAAc,CAwBhB"}

package/dist/domain/connection-detection/call-graph/type-resolver.js

@@ -0,0 +1,128 @@
+import { CallExpression, SourceFile, Node } from 'ts-morph';
+import { ConnectionDetectionError } from '../connection-detection-error';
+function stripGenerics(typeName) {
+    const angleBracketIndex = typeName.indexOf('<');
+    if (angleBracketIndex === -1)
+        return typeName;
+    return typeName.slice(0, angleBracketIndex);
+}
+function stripPromise(typeName) {
+    if (typeName.startsWith('Promise<') && typeName.endsWith('>')) {
+        return typeName.slice(8, -1);
+    }
+    return typeName;
+}
+const UNRESOLVABLE_TYPES = new Set(['any', 'unknown', 'object']);
+function isUnresolvableType(typeName) {
+    return UNRESOLVABLE_TYPES.has(typeName);
+}
+function getReceiverExpression(callExpression) {
+    const expression = callExpression.getExpression();
+    if (Node.isPropertyAccessExpression(expression)) {
+        return expression.getExpression();
+    }
+    return undefined;
+}
+function extractTypeNameFromType(type) {
+    const symbol = type.getSymbol() ?? type.getAliasSymbol();
+    return symbol?.getName() ?? type.getText();
+}
+function resolveCallExpressionReturnType(callExpr) {
+    const expr = callExpr.getExpression();
+    if (!Node.isPropertyAccessExpression(expr))
+        return undefined;
+    const methodName = expr.getName();
+    const receiverType = expr.getExpression().getType();
+    const receiverSymbol = receiverType.getSymbol();
+    if (!receiverSymbol)
+        return undefined;
+    for (const decl of receiverSymbol.getDeclarations()) {
+        if (!Node.isClassDeclaration(decl))
+            continue;
+        const method = decl.getMethod(methodName);
+        if (!method)
+            continue;
+        const returnTypeNode = method.getReturnTypeNode();
+        if (returnTypeNode) {
+            return stripPromise(returnTypeNode.getText());
+        }
+    }
+    return undefined;
+}
+function resolveAwaitedCallReturnType(initializer) {
+    if (!Node.isAwaitExpression(initializer))
+        return undefined;
+    const awaited = initializer.getExpression();
+    if (!Node.isCallExpression(awaited))
+        return undefined;
+    return resolveCallExpressionReturnType(awaited);
+}
+function resolveFromVariableDeclaration(identifier) {
+    if (!Node.isIdentifier(identifier))
+        return undefined;
+    const defs = identifier.getDefinitionNodes();
+    const [firstDef] = defs;
+    if (!firstDef || !Node.isVariableDeclaration(firstDef))
+        return undefined;
+    const typeNode = firstDef.getTypeNode();
+    if (typeNode)
+        return typeNode.getText();
+    const initializer = firstDef.getInitializer();
+    if (initializer)
+        return resolveAwaitedCallReturnType(initializer);
+    return undefined;
+}
+function resolveReceiverTypeName(receiver) {
+    if (Node.isCallExpression(receiver)) {
+        const returnType = resolveCallExpressionReturnType(receiver);
+        if (returnType)
+            return returnType;
+    }
+    const type = receiver.getType();
+    const rawName = extractTypeNameFromType(type);
+    if (isUnresolvableType(rawName)) {
+        const resolved = resolveFromVariableDeclaration(receiver);
+        if (resolved)
+            return resolved;
+    }
+    return rawName;
+}
+function buildError(sourceFile, callExpression, typeName, reason) {
+    return new ConnectionDetectionError({
+        file: sourceFile.getFilePath(),
+        line: callExpression.getStartLineNumber(),
+        typeName,
+        reason,
+    });
+}
+function handleUnresolvable(sourceFile, callExpression, rawTypeName, options) {
+    const reason = `Receiver type is '${rawTypeName}' — no concrete type to resolve`;
+    if (options.strict) {
+        throw buildError(sourceFile, callExpression, rawTypeName, reason);
+    }
+    return {
+        resolved: false,
+        reason,
+    };
+}
+export function resolveCallExpressionReceiverType(callExpression, sourceFile, options) {
+    const receiver = getReceiverExpression(callExpression);
+    if (!receiver) {
+        const reason = 'Call expression has no property access receiver';
+        if (options.strict) {
+            throw buildError(sourceFile, callExpression, 'unknown', reason);
+        }
+        return {
+            resolved: false,
+            reason,
+        };
+    }
+    const rawTypeName = resolveReceiverTypeName(receiver);
+    if (isUnresolvableType(rawTypeName)) {
+        return handleUnresolvable(sourceFile, callExpression, rawTypeName, options);
+    }
+    return {
+        resolved: true,
+        typeName: stripGenerics(rawTypeName),
+    };
+}

package/dist/domain/connection-detection/component-index.d.ts

@@ -0,0 +1,10 @@
+import type { EnrichedComponent } from '../value-extraction/enrich-components';
+export declare class ComponentIndex {
+    private readonly byName;
+    private readonly byLocation;
+    constructor(components: readonly EnrichedComponent[]);
+    isComponent(typeName: string): boolean;
+    getComponentByTypeName(typeName: string): EnrichedComponent | undefined;
+    getComponentByLocation(file: string, line: number): EnrichedComponent | undefined;
+}
+//# sourceMappingURL=component-index.d.ts.map

package/dist/domain/connection-detection/component-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-index.d.ts","sourceRoot":"","sources":["../../../src/domain/connection-detection/component-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAA;AAO9E,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwC;gBAEvD,UAAU,EAAE,SAAS,iBAAiB,EAAE;IAapD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAItC,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIvE,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;CAGlF"}

package/dist/domain/connection-detection/component-index.js

@@ -0,0 +1,27 @@
+import { stripGenericArgs } from './call-graph/call-graph-types';
+function locationKey(file, line) {
+    return `${file}:${line}`;
+}
+export class ComponentIndex {
+    byName;
+    byLocation;
+    constructor(components) {
+        const nameMap = new Map();
+        const locationMap = new Map();
+        for (const component of components) {
+            nameMap.set(component.name, component);
+            locationMap.set(locationKey(component.location.file, component.location.line), component);
+        }
+        this.byName = nameMap;
+        this.byLocation = locationMap;
+    }
+    isComponent(typeName) {
+        return this.byName.has(stripGenericArgs(typeName));
+    }
+    getComponentByTypeName(typeName) {
+        return this.byName.get(stripGenericArgs(typeName));
+    }
+    getComponentByLocation(file, line) {
+        return this.byLocation.get(locationKey(file, line));
+    }
+}

package/dist/domain/connection-detection/connection-detection-error.d.ts

@@ -0,0 +1,13 @@
+export declare class ConnectionDetectionError extends Error {
+    readonly file: string;
+    readonly line: number;
+    readonly typeName: string;
+    readonly reason: string;
+    constructor(params: {
+        file: string;
+        line: number;
+        typeName: string;
+        reason: string;
+    });
+}
+//# sourceMappingURL=connection-detection-error.d.ts.map

package/dist/domain/connection-detection/connection-detection-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-detection-error.d.ts","sourceRoot":"","sources":["../../../src/domain/connection-detection/connection-detection-error.ts"],"names":[],"mappings":"AAAA,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;gBAEX,MAAM,EAAE;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAA;KACf;CAUF"}

package/dist/domain/connection-detection/connection-detection-error.js

@@ -0,0 +1,14 @@
+export class ConnectionDetectionError extends Error {
+    file;
+    line;
+    typeName;
+    reason;
+    constructor(params) {
+        super(`Connection detection failed for ${params.typeName} at ${params.file}:${params.line}: ${params.reason}`);
+        this.name = 'ConnectionDetectionError';
+        this.file = params.file;
+        this.line = params.line;
+        this.typeName = params.typeName;
+        this.reason = params.reason;
+    }
+}

package/dist/domain/connection-detection/detect-connections.d.ts

@@ -0,0 +1,10 @@
+import type { Project } from 'ts-morph';
+import type { EnrichedComponent } from '../value-extraction/enrich-components';
+import type { GlobMatcher } from '../component-extraction/extractor';
+import type { ExtractedLink } from './extracted-link';
+export interface ConnectionDetectionOptions {
+    allowIncomplete?: boolean;
+    moduleGlobs: string[];
+}
+export declare function detectConnections(project: Project, components: readonly EnrichedComponent[], options: ConnectionDetectionOptions, globMatcher: GlobMatcher): ExtractedLink[];
+//# sourceMappingURL=detect-connections.d.ts.map

package/dist/domain/connection-detection/detect-connections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-connections.d.ts","sourceRoot":"","sources":["../../../src/domain/connection-detection/detect-connections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAA;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAIrD,MAAM,WAAW,0BAA0B;IACzC,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB;AAaD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,OAAO,EAAE,0BAA0B,EACnC,WAAW,EAAE,WAAW,GACvB,aAAa,EAAE,CAOjB"}

package/dist/domain/connection-detection/detect-connections.js

@@ -0,0 +1,16 @@
+import { ComponentIndex } from './component-index';
+import { buildCallGraph } from './call-graph/build-call-graph';
+function computeFilteredFilePaths(project, moduleGlobs, globMatcher) {
+    return project
+        .getSourceFiles()
+        .map((sf) => sf.getFilePath())
+        .filter((filePath) => moduleGlobs.some((glob) => globMatcher(filePath, glob)));
+}
+export function detectConnections(project, components, options, globMatcher) {
+    const componentIndex = new ComponentIndex(components);
+    const sourceFilePaths = computeFilteredFilePaths(project, options.moduleGlobs, globMatcher);
+    return buildCallGraph(project, components, componentIndex, {
+        strict: !options.allowIncomplete,
+        sourceFilePaths,
+    });
+}

package/dist/domain/connection-detection/extracted-link.d.ts

@@ -0,0 +1,5 @@
+import type { Link } from '@living-architecture/riviere-schema';
+export interface ExtractedLink extends Link {
+    _uncertain?: string;
+}
+//# sourceMappingURL=extracted-link.d.ts.map

package/dist/domain/connection-detection/extracted-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extracted-link.d.ts","sourceRoot":"","sources":["../../../src/domain/connection-detection/extracted-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qCAAqC,CAAA;AAE/D,MAAM,WAAW,aAAc,SAAQ,IAAI;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAC"}

package/dist/domain/connection-detection/extracted-link.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/connection-detection/interface-resolution/resolve-interface.d.ts

@@ -0,0 +1,16 @@
+import { Project } from 'ts-morph';
+interface InterfaceResolutionResult {
+    resolved: true;
+    typeName: string;
+}
+interface InterfaceUnresolved {
+    resolved: false;
+    reason: string;
+    typeDefinedInSource: boolean;
+}
+export type InterfaceResolution = InterfaceResolutionResult | InterfaceUnresolved;
+export declare function resolveInterface(interfaceName: string, project: Project, sourceFilePaths: string[], options: {
+    strict: boolean;
+}): InterfaceResolution;
+export {};
+//# sourceMappingURL=resolve-interface.d.ts.map

package/dist/domain/connection-detection/interface-resolution/resolve-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-interface.d.ts","sourceRoot":"","sources":["../../../../src/domain/connection-detection/interface-resolution/resolve-interface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACR,MAAM,UAAU,CAAA;AAGjB,UAAU,yBAAyB;IACjC,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,KAAK,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,mBAAmB,EAAE,OAAO,CAAA;CAC7B;AAED,MAAM,MAAM,mBAAmB,GAAG,yBAAyB,GAAG,mBAAmB,CAAA;AA+DjF,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EAAE,EACzB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAC3B,mBAAmB,CAuCrB"}

package/dist/domain/connection-detection/interface-resolution/resolve-interface.js

@@ -0,0 +1,79 @@
+import { Project, ClassDeclaration, SourceFile } from 'ts-morph';
+import { ConnectionDetectionError } from '../connection-detection-error';
+function isNodeModulesPath(filePath) {
+    return filePath.includes('node_modules');
+}
+function isMatchingClass(classDecl, interfaceName) {
+    return (implementsInterface(classDecl, interfaceName) || extendsAbstractClass(classDecl, interfaceName));
+}
+function getClassesFromFiles(sourceFiles) {
+    return sourceFiles.flatMap((sf) => sf.getClasses());
+}
+function findImplementations(interfaceName, sourceFiles) {
+    return getClassesFromFiles(sourceFiles)
+        .filter((classDecl) => isMatchingClass(classDecl, interfaceName))
+        .map((classDecl) => classDecl.getName())
+        .filter((name) => name !== undefined);
+}
+function isDefinedInSourceFiles(typeName, sourceFiles) {
+    return sourceFiles.some((sf) => sf.getInterfaces().some((i) => i.getName() === typeName) ||
+        sf.getClasses().some((c) => c.getName() === typeName && c.isAbstract()));
+}
+function getExpressionName(expression) {
+    return expression.getType().getSymbol()?.getName() ?? expression.getText();
+}
+function implementsInterface(classDecl, interfaceName) {
+    return classDecl
+        .getImplements()
+        .some((impl) => getExpressionName(impl.getExpression()) === interfaceName);
+}
+function extendsAbstractClass(classDecl, abstractName) {
+    const extendsClause = classDecl.getExtends();
+    if (extendsClause === undefined) {
+        return false;
+    }
+    return getExpressionName(extendsClause.getExpression()) === abstractName;
+}
+function createError(interfaceName, reason) {
+    return new ConnectionDetectionError({
+        file: '',
+        line: 0,
+        typeName: interfaceName,
+        reason,
+    });
+}
+export function resolveInterface(interfaceName, project, sourceFilePaths, options) {
+    const filteredPaths = sourceFilePaths.filter((p) => !isNodeModulesPath(p));
+    const sourceFiles = filteredPaths
+        .map((p) => project.getSourceFile(p))
+        .filter((sf) => sf !== undefined);
+    const implementations = findImplementations(interfaceName, sourceFiles);
+    const [singleImpl] = implementations;
+    if (implementations.length === 1 && singleImpl) {
+        return {
+            resolved: true,
+            typeName: singleImpl,
+        };
+    }
+    if (implementations.length === 0) {
+        const definedInSource = isDefinedInSourceFiles(interfaceName, sourceFiles);
+        const reason = `No implementation found for ${interfaceName}`;
+        if (definedInSource && options.strict) {
+            throw createError(interfaceName, reason);
+        }
+        return {
+            resolved: false,
+            reason,
+            typeDefinedInSource: definedInSource,
+        };
+    }
+    const reason = `Multiple implementations found for ${interfaceName} (${implementations.length}): ${implementations.join(', ')}`;
+    if (options.strict) {
+        throw createError(interfaceName, reason);
+    }
+    return {
+        resolved: false,
+        reason,
+        typeDefinedInSource: true,
+    };
+}

package/dist/domain/value-extraction/enrich-components.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enrich-components.d.ts","sourceRoot":"","sources":["../../../src/domain/value-extraction/enrich-components.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACQ,OAAO,EAC1B,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,wBAAwB,EAQzB,MAAM,6CAA6C,CAAA;AACpD,OAAO,KAAK,EACV,cAAc,EAAE,WAAW,EAC5B,MAAM,mCAAmC,CAAA;AAU1C,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAA;AAEzD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACvC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,cAAc,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,iBAAiB,EAAE,CAAA;IAC/B,QAAQ,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AAuND,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,cAAc,EAAE,EACjC,MAAM,EAAE,wBAAwB,EAChC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,GAChB,gBAAgB,CAclB"}
+{"version":3,"file":"enrich-components.d.ts","sourceRoot":"","sources":["../../../src/domain/value-extraction/enrich-components.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAC2B,OAAO,EAC7C,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EACV,wBAAwB,EAUzB,MAAM,6CAA6C,CAAA;AACpD,OAAO,KAAK,EACV,cAAc,EAAE,WAAW,EAC5B,MAAM,mCAAmC,CAAA;AAY1C,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,CAAA;AAEzD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACvC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,cAAc,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,iBAAiB,EAAE,CAAA;IAC/B,QAAQ,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AA6RD,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,cAAc,EAAE,EACjC,MAAM,EAAE,wBAAwB,EAChC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,GAChB,gBAAgB,CAclB"}

package/dist/domain/value-extraction/enrich-components.js

@@ -1,5 +1,6 @@
 import { posix } from 'node:path';
-import { evaluateLiteralRule, evaluateFromClassNameRule, evaluateFromFilePathRule, evaluateFromPropertyRule, } from './evaluate-extraction-rule';
+import { evaluateLiteralRule, evaluateFromClassNameRule, evaluateFromFilePathRule, evaluateFromPropertyRule, evaluateFromMethodNameRule, } from './evaluate-extraction-rule';
+import { evaluateFromGenericArgRule } from './evaluate-extraction-rule-generic';
 import { ExtractionError } from '../../platform/domain/ast-literals/literal-detection';
 function findMatchingModule(filePath, modules, globMatcher, configDir) {
     const normalized = filePath.replaceAll(/\\+/g, '/');
@@ -54,6 +55,12 @@ function isFromFilePathRule(rule) {
 function isFromPropertyRule(rule) {
     return 'fromProperty' in rule;
 }
+function isFromMethodNameRule(rule) {
+    return 'fromMethodName' in rule;
+}
+function isFromGenericArgRule(rule) {
+    return 'fromGenericArg' in rule;
+}
 function findClassAtLine(project, draft) {
     const sourceFile = project.getSourceFile(draft.location.file);
     if (sourceFile === undefined) {
@@ -67,6 +74,36 @@ function findClassAtLine(project, draft) {
     }
     return classDecl;
 }
+function findMethodAtLine(project, draft) {
+    const sourceFile = project.getSourceFile(draft.location.file);
+    if (sourceFile === undefined) {
+        throw new ExtractionError(`Source file '${draft.location.file}' not found in project`, draft.location.file, draft.location.line);
+    }
+    for (const classDecl of sourceFile.getClasses()) {
+        const method = classDecl
+            .getMethods()
+            .find((m) => m.getStartLineNumber() === draft.location.line);
+        if (method !== undefined) {
+            return method;
+        }
+    }
+    throw new ExtractionError(`No method declaration found at line ${draft.location.line}`, draft.location.file, draft.location.line);
+}
+function findContainingClass(project, draft) {
+    const sourceFile = project.getSourceFile(draft.location.file);
+    if (sourceFile === undefined) {
+        throw new ExtractionError(`Source file '${draft.location.file}' not found in project`, draft.location.file, draft.location.line);
+    }
+    const methodLine = draft.location.line;
+    for (const classDecl of sourceFile.getClasses()) {
+        const classStart = classDecl.getStartLineNumber();
+        const classEnd = classDecl.getEndLineNumber();
+        if (methodLine >= classStart && methodLine <= classEnd) {
+            return classDecl;
+        }
+    }
+    throw new ExtractionError(`No containing class found for method at line ${methodLine}`, draft.location.file, draft.location.line);
+}
 function evaluateClassRule(rule, classDecl) {
     if (isFromClassNameRule(rule)) {
         return evaluateFromClassNameRule(rule, classDecl);
@@ -84,6 +121,14 @@ function evaluateRule(rule, draft, project) {
     if (isFromFilePathRule(rule)) {
         return evaluateFromFilePathRule(rule, draft.location.file);
     }
+    if (isFromMethodNameRule(rule)) {
+        const methodDecl = findMethodAtLine(project, draft);
+        return evaluateFromMethodNameRule(rule, methodDecl);
+    }
+    if (isFromGenericArgRule(rule)) {
+        const classDecl = findContainingClass(project, draft);
+        return evaluateFromGenericArgRule(rule, classDecl);
+    }
     const classDecl = findClassAtLine(project, draft);
     return evaluateClassRule(rule, classDecl);
 }

package/dist/shell/index.d.ts

@@ -4,5 +4,9 @@ export { resolveConfig, type ConfigLoader } from '../domain/config-resolution/re
 export { ConfigLoaderRequiredError, MissingComponentRuleError, } from '../domain/config-resolution/config-resolution-errors';
 export { evaluateLiteralRule, evaluateFromClassNameRule, evaluateFromMethodNameRule, evaluateFromFilePathRule, evaluateFromPropertyRule, evaluateFromDecoratorArgRule, evaluateFromDecoratorNameRule, evaluateFromGenericArgRule, evaluateFromMethodSignatureRule, evaluateFromConstructorParamsRule, evaluateFromParameterTypeRule, applyTransforms, ExtractionError, type ExtractionContext, type ExtractionResult, type ParameterInfo, type MethodSignature, } from '../domain/value-extraction';
 export { matchesGlob } from '../platform/infra/glob-matching/minimatch-glob';
+export { detectConnections, type ConnectionDetectionOptions, } from '../domain/connection-detection/detect-connections';
+export type { ExtractedLink } from '../domain/connection-detection/extracted-link';
+export { ComponentIndex } from '../domain/connection-detection/component-index';
+export { ConnectionDetectionError } from '../domain/connection-detection/connection-detection-error';
 export { enrichComponents, type EnrichedComponent, type EnrichmentFailure, type EnrichmentResult, } from '../domain/value-extraction/enrich-components';
 //# sourceMappingURL=index.d.ts.map

package/dist/shell/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shell/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,GACjB,MAAM,0CAA0C,CAAA;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mDAAmD,CAAA;AACrF,OAAO,EACL,aAAa,EAAE,KAAK,YAAY,EACjC,MAAM,4CAA4C,CAAA;AACnD,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,sDAAsD,CAAA;AAC7D,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,6BAA6B,EAC7B,0BAA0B,EAC1B,+BAA+B,EAC/B,iCAAiC,EACjC,6BAA6B,EAC7B,eAAe,EACf,eAAe,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,GACrB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,gDAAgD,CAAA;AAC5E,OAAO,EACL,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,8CAA8C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shell/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,WAAW,GACjB,MAAM,0CAA0C,CAAA;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mDAAmD,CAAA;AACrF,OAAO,EACL,aAAa,EAAE,KAAK,YAAY,EACjC,MAAM,4CAA4C,CAAA;AACnD,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,sDAAsD,CAAA;AAC7D,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,6BAA6B,EAC7B,0BAA0B,EAC1B,+BAA+B,EAC/B,iCAAiC,EACjC,6BAA6B,EAC7B,eAAe,EACf,eAAe,EACf,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,GACrB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,gDAAgD,CAAA;AAC5E,OAAO,EACL,iBAAiB,EACjB,KAAK,0BAA0B,GAChC,MAAM,mDAAmD,CAAA;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,+CAA+C,CAAA;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAA;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,2DAA2D,CAAA;AACpG,OAAO,EACL,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,8CAA8C,CAAA"}

package/dist/shell/index.js

@@ -4,4 +4,7 @@ export { resolveConfig } from '../domain/config-resolution/resolve-config';
 export { ConfigLoaderRequiredError, MissingComponentRuleError, } from '../domain/config-resolution/config-resolution-errors';
 export { evaluateLiteralRule, evaluateFromClassNameRule, evaluateFromMethodNameRule, evaluateFromFilePathRule, evaluateFromPropertyRule, evaluateFromDecoratorArgRule, evaluateFromDecoratorNameRule, evaluateFromGenericArgRule, evaluateFromMethodSignatureRule, evaluateFromConstructorParamsRule, evaluateFromParameterTypeRule, applyTransforms, ExtractionError, } from '../domain/value-extraction';
 export { matchesGlob } from '../platform/infra/glob-matching/minimatch-glob';
+export { detectConnections, } from '../domain/connection-detection/detect-connections';
+export { ComponentIndex } from '../domain/connection-detection/component-index';
+export { ConnectionDetectionError } from '../domain/connection-detection/connection-detection-error';
 export { enrichComponents, } from '../domain/value-extraction/enrich-components';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-extract-ts",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,6 +24,7 @@
   "dependencies": {
     "minimatch": "^10.0.1",
     "ts-morph": "^24.0.0",
-    "@living-architecture/riviere-extract-config": "0.4.1"
+    "@living-architecture/riviere-extract-config": "0.4.2",
+    "@living-architecture/riviere-schema": "0.5.2"
   }
 }