@filipebraida/adonis-function-points 0.1.0 → 0.2.0

package/build/{resolvers-CU9HKYpn.js → resolvers-MFjRl2ef.js}

@@ -1,4 +1,4 @@
-import { Node, SyntaxKind } from "ts-morph";
+import { Node, Project, SyntaxKind } from "ts-morph";
 //#region src/inventory/resolvers/action_object.ts
 /**
 * "Action object" pattern: the transaction delegates to an action instantiated
@@ -50,14 +50,211 @@ function classOfReceiver(receiver) {
 	return null;
 }
 //#endregion
+//#region src/inventory/paths.ts
+/**
+* One canonical spelling for every path the inventory emits.
+*
+* Two path styles meet in this package. ts-morph always returns forward
+* slashes, including on Windows; node's `path.join` returns backslashes there.
+* Both end up in `HandlerRef.file`, and the call graph uses that string as a
+* cache key:
+*
+*     const key = `${ref.file}#${ref.member ?? ref.line ?? '*'}`
+*
+* Two spellings of the same file are two keys, so the same body would be
+* analysed twice and pushed twice into the trace and the implementation scope
+* — and a repeated scope entry changes the hash `fp:diff` compares.
+*
+* Forward slashes win because ts-morph cannot be told otherwise, node's `fs`
+* accepts them on Windows, and `path.relative` normalises mixed input anyway.
+* Normalising at the boundary where a path is created costs one call; leaving
+* it to each comparison costs vigilance forever.
+*/
+const toPosix = (value) => value.split("\\").join("/");
+/** Compares two paths that may have come from different sources. */
+const samePath = (a, b) => a !== void 0 && b !== void 0 && toPosix(a) === toPosix(b);
+//#endregion
+//#region src/inventory/sources/event_bindings.ts
+/** the method a listener declares; AdonisJS calls `handle` unless told otherwise */
+const LISTENER_METHOD = "handle";
+function collectEventBindings(app) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		skipFileDependencyResolution: true,
+		compilerOptions: { allowJs: false }
+	});
+	for (const root of app.scanRoots) project.addSourceFilesAtPaths(`${root}/**/*.ts`);
+	const bindings = /* @__PURE__ */ new Map();
+	for (const file of project.getSourceFiles()) for (const call of file.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+		const expression = call.getExpression();
+		if (!Node.isPropertyAccessExpression(expression)) continue;
+		if (expression.getName() !== "on") continue;
+		const [event, handlers] = call.getArguments();
+		if (!event || !handlers) continue;
+		const eventFile = resolveEventClass(event, file, app);
+		if (!eventFile) continue;
+		const refs = listenersOf(handlers, file, app);
+		if (refs.length === 0) continue;
+		bindings.set(eventFile, [...bindings.get(eventFile) ?? [], ...refs]);
+	}
+	return bindings;
+}
+/**
+* The event class a dispatch or a binding names.
+*
+* Two shapes reach here: the class imported directly, and the generated
+* registry (`events.OrderPlaced`), which is what `node ace make:event` produces
+* and therefore the common one. Exported because the resolver has to ask the
+* same question of a call site, and two implementations of "which event is
+* this" would drift.
+*/
+function resolveEventClass(expression, from, app) {
+	if (Node.isIdentifier(expression)) {
+		const target = importedFrom(expression.getText(), from, app);
+		return target ? toPosix(target) : null;
+	}
+	if (!Node.isPropertyAccessExpression(expression)) return null;
+	const root = expression.getExpression();
+	if (!Node.isIdentifier(root)) return null;
+	const registry = importedFrom(root.getText(), from, app);
+	if (!registry) return null;
+	return registryEntry(registry, expression.getName(), from.getProject(), app);
+}
+/** listener bodies named by the second argument of `emitter.on` */
+function listenersOf(handlers, from, app) {
+	const entries = handlers.isKind(SyntaxKind.ArrayLiteralExpression) ? handlers.getElements() : [handlers];
+	const refs = [];
+	for (const entry of entries) {
+		/**
+		* `[SomeListener, 'method']`: AdonisJS lets the binding name the method,
+		* and taking `handle` on faith there would look for a body that is not
+		* the one bound.
+		*/
+		if (entry.isKind(SyntaxKind.ArrayLiteralExpression)) {
+			const [target, member] = entry.getElements();
+			const file = target ? listenerFile(target, from, app) : null;
+			if (!file) continue;
+			const named = member?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+			refs.push({
+				file,
+				member: named ?? LISTENER_METHOD
+			});
+			continue;
+		}
+		const file = listenerFile(entry, from, app);
+		if (file) refs.push({
+			file,
+			member: LISTENER_METHOD
+		});
+	}
+	return refs;
+}
+function listenerFile(entry, from, app) {
+	if (Node.isPropertyAccessExpression(entry)) {
+		const root = entry.getExpression();
+		if (!Node.isIdentifier(root)) return null;
+		const registry = importedFrom(root.getText(), from, app);
+		return registry ? registryEntry(registry, entry.getName(), from.getProject(), app) : null;
+	}
+	if (Node.isIdentifier(entry)) {
+		const target = importedFrom(entry.getText(), from, app);
+		return target ? toPosix(target) : null;
+	}
+	return null;
+}
+/** where a local identifier was imported from, resolved through the alias map */
+function importedFrom(local, from, app) {
+	for (const declaration of from.getImportDeclarations()) {
+		const named = declaration.getNamedImports().some((entry) => (entry.getAliasNode()?.getText() ?? entry.getName()) === local);
+		const isDefault = declaration.getDefaultImport()?.getText() === local;
+		if (!named && !isDefault) continue;
+		return app.resolveSpecifier(declaration.getModuleSpecifierValue());
+	}
+	return null;
+}
+/**
+* The file a key of a generated registry points at.
+*
+* Both shapes the generators emit are handled: a direct reference to an
+* imported class (`events.ts`) and a lazy importer (`listeners.ts`). They differ
+* per artefact and per framework version, and reading only one of them silently
+* lost half the graph.
+*/
+function registryEntry(registryFile, key, project, app) {
+	const file = project.getSourceFile(registryFile) ?? project.addSourceFileAtPathIfExists(registryFile);
+	if (!file) return null;
+	for (const declaration of file.getVariableDeclarations()) {
+		const value = ((declaration.getInitializer()?.asKind(SyntaxKind.ObjectLiteralExpression))?.getProperty(key)?.asKind(SyntaxKind.PropertyAssignment))?.getInitializer();
+		if (!value) continue;
+		if (Node.isIdentifier(value)) {
+			const target = importedFrom(value.getText(), file, app);
+			return target ? toPosix(target) : null;
+		}
+		const specifier = value.getFirstDescendantByKind(SyntaxKind.CallExpression)?.getArguments()[0]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+		const target = specifier ? app.resolveSpecifier(specifier) : null;
+		return target ? toPosix(target) : null;
+	}
+	return null;
+}
+//#endregion
+//#region src/inventory/resolvers/event_dispatch.ts
+/**
+* "Event" pattern: the handler announces, and listeners act.
+*
+*     await events.OrderPlaced.dispatch(order.id)
+*
+* Runs BEFORE `job-dispatch`, which matches `Identifier.dispatch(args)` — the
+* shape the direct form takes. Left to it, the event class was resolved and
+* searched for a `handle` it does not declare (`dispatch` comes from
+* `BaseEvent`), so the call was reported as an unknown and the listeners' reads
+* and writes went uncounted.
+*
+* COUNTING DECISION: the same one taken for a job. The user clicks, the effect
+* happens, and AFP §6.5.3 requires aggregating every path the transaction
+* reaches — the emitter is an implementation detail of how it gets there.
+*/
+const eventDispatchResolver = {
+	name: "event-dispatch",
+	order: 12,
+	resolve(call, ctx) {
+		if (ctx.eventBindings.size === 0) return [];
+		const expression = call.getExpression();
+		if (!expression.isKind(SyntaxKind.PropertyAccessExpression)) return [];
+		if (expression.getName() !== "dispatch") return [];
+		const receiver = expression.getExpression();
+		if (!Node.isIdentifier(receiver) && !Node.isPropertyAccessExpression(receiver)) return [];
+		const eventFile = resolveEventClass(receiver, ctx.file, { resolveSpecifier: ctx.resolveSpecifier });
+		return eventFile ? ctx.eventBindings.get(eventFile) ?? [] : [];
+	}
+};
+//#endregion
 //#region src/inventory/resolvers/job_dispatch.ts
 const DISPATCH_METHODS = new Set([
 	"dispatch",
+	"dispatchMany",
 	"dispatchLater",
 	"enqueue",
 	"later"
 ]);
 /**
+* The method that actually runs the job, by queue package.
+*
+* There is no single name: `@adonisjs/queue` and `@rlanz/bull-queue` call it
+* `handle`, `@nemoventures/adonis-jobs` calls it `process`. Looking only for
+* `handle` meant every job in an application using the second one resolved to
+* a file and then to no body, so the dispatch was reported as an unknown while
+* the writes inside it went uncounted — the worst of both outcomes.
+*
+* Ordered: a class declaring more than one is answering the dispatcher with the
+* first, and `handle` is the most common.
+*/
+const EXECUTION_METHODS = [
+	"handle",
+	"process",
+	"run",
+	"perform"
+];
+/**
 * "Job" pattern: the write happens asynchronously.
 *
 *     await CreateUserJob.dispatch({ userId })
@@ -86,9 +283,16 @@ const jobDispatchResolver = {
 		if (ctx.dataStoresBySymbol.has(symbol)) return [];
 		const file = ctx.imports.get(symbol);
 		if (!file) return [];
+		/**
+		* `dispatch` enqueues; the execution method is what touches data. When the
+		* class declares one, that is the body that matters — and when it declares
+		* none, the dispatch name is kept so the gap stays visible instead of being
+		* quietly attributed to a body nobody found.
+		*/
+		const classes = ctx.sourceFile(file)?.getClasses() ?? [];
 		return [{
 			file,
-			member: ctx.sourceFile(file)?.getClasses().some((c) => c.getMethod("handle")) ? "handle" : expr.getName()
+			member: EXECUTION_METHODS.find((name) => classes.some((c) => c.getMethod(name))) ?? expr.getName()
 		}];
 	}
 };
@@ -109,11 +313,17 @@ const moduleFunctionResolver = {
 	resolve(call, ctx) {
 		const expr = call.getExpression();
 		if (!expr.isKind(SyntaxKind.Identifier)) return [];
-		const file = ctx.imports.get(expr.getText());
+		const local = expr.getText();
+		const file = ctx.imports.get(local);
 		if (!file) return [];
+		/**
+		* The body carries the exported name, not the local one. Following the
+		* local name through an alias finds nothing and reports the call as
+		* unresolved for a reason that is not true.
+		*/
 		return [{
 			file,
-			member: expr.getText()
+			member: ctx.exportedAs.get(local) ?? local
 		}];
 	}
 };
@@ -526,6 +736,7 @@ function extendsTransformer(file) {
 const BUILTIN_CALL_RESOLVERS = [
 	sameClassMethodResolver,
 	actionObjectResolver,
+	eventDispatchResolver,
 	jobDispatchResolver,
 	transformerResolver,
 	staticServiceResolver,
@@ -543,6 +754,15 @@ const BUILTIN_CALL_RESOLVERS = [
 */
 function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	for (const resolver of resolvers) {
+		/**
+		* Asked before `resolve`, and in the same order: a strategy that claims a
+		* call as data-free must not be overtaken by a later, more generic one
+		* following it into a body it has no business reading.
+		*/
+		if (resolver.ignores?.(call, ctx)) return {
+			by: resolver.name,
+			refs: []
+		};
 		const refs = resolver.resolve(call, ctx);
 		if (refs.length > 0) return {
 			by: resolver.name,
@@ -552,4 +772,4 @@ function resolveCall(call, ctx, resolvers = BUILTIN_CALL_RESOLVERS) {
 	return null;
 }
 //#endregion
-export { rootSymbolOf as a, hooksFiredBy as i, resolveCall as n, detectAccess as r, BUILTIN_CALL_RESOLVERS as t };
+export { rootSymbolOf as a, toPosix as c, hooksFiredBy as i, resolveCall as n, collectEventBindings as o, detectAccess as r, samePath as s, BUILTIN_CALL_RESOLVERS as t };