@filipebraida/adonis-function-points 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -6,6 +6,46 @@ release moves the number for unchanged code, the rule set version moves with it
 otherwise the difference would measure the tool's change rather than the work, and
 that difference becomes an invoice.
 
+## 0.10.0
+
+**Rule set `afp@1.9.0`.** One rule and two report fixes, from a team's third review of their
+own count — the one they accepted as a baseline. The rule moves no point on the three
+validated applications and no point on its fixture: it moves a gap from the wrong line to
+the right one. A 0.9.0 baseline still has to be recounted, because the rule set says so.
+
+### Fixed
+
+- **A warning names a transaction the way the table and the config keys do.** Four warnings
+  printed the route's own pattern (`GET /orders/:id`) where the table, `fp:explain` and the
+  keys of `overrides` / `boundary.ignoreEntryPoints` use the identity (`GET /orders/:param`,
+  §5). Copying from a warning into the configuration required a translation nobody was told
+  about. All of them print the identity now.
+- **"leaves whole — page never reads X" contradicted itself.** The rule was right — a store
+  handed to a page that uses nothing of it the reader can see leaves whole, in the open, never
+  as a floor — and the sentence was not. It says now: "handed to page "x", and nothing the
+  reader can see uses X: every column counted, in the open".
+
+### Counting
+
+- **The value of a transaction callback is what it returns.** `const { row } = await
+db.transaction(async (trx) => { … return { row: created } })`, then `row.save()`: the write
+  was an unreadable receiver. The callback is a body — its own locals are bound first, in
+  source order — and every `return` names the store the value holds, whole or under one key
+  of a returned literal; `Model.transaction` and `trx.transaction` are the same shape. A
+  returned number binds nothing; a raw-query row nobody can type stays reported. On the three
+  applications the value of a transaction callback is used 17 times. The 0.8 rule "a value a
+  package built is not a store" narrows to a call with no function argument: `db` is a
+  package import, and `db.transaction(cb)` hands back the application's value.
+
+### Documented
+
+- counting-decisions §3 gains the transaction-callback row of the bindings table.
+- Fixtures: `transacao_valor` (18 FP — the same before and after; one unresolved call moves
+  from `row.save` to the raw-query row that deserves it); `inertia_pages` grows a page that
+  uses nothing of its rows (29 FP).
+- Measured and set aside: a model's instance method that writes — one in 52 models on the
+  three applications, not a rule.
+
 ## 0.9.0
 
 **Rule set `afp@1.8.0`.** Two rules from a team's second review of their own count, one

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.8.0
+Ruleset: afp@1.9.0
 
 type      n     FP
 ILF       2     14

package/build/commands/main.js

@@ -14,27 +14,27 @@
 const commands = [
 	{
 		commandName: "fp:inventory",
-		importer: () => import("../fp_inventory-B4Pv8Thz.js")
+		importer: () => import("../fp_inventory-BJlIoetL.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-DoS5riGr.js")
+		importer: () => import("../fp_metrics-BDKaNL0B.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-Bjviq8dz.js")
+		importer: () => import("../fp_count-B5hxDyGJ.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-CrFcMeXU.js")
+		importer: () => import("../fp_explain-C4X_-Rp7.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-BSK1kKLQ.js")
+		importer: () => import("../fp_diff-7S8NcKIY.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-DJspMFHc.js")
+		importer: () => import("../fp_calibrate-DUPUXVaJ.js")
 	}
 ];
 let cache = null;

package/build/{fp_calibrate-DJspMFHc.js → fp_calibrate-DUPUXVaJ.js}

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-BuZNr-FE.js";
+import { s as printResult, t as runCalibrate } from "./runners-b1tgLA1B.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_calibrate.ts

package/build/{fp_count-Bjviq8dz.js → fp_count-B5hxDyGJ.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-BuZNr-FE.js";
+import { n as runCount, s as printResult } from "./runners-b1tgLA1B.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_count.ts

package/build/{fp_diff-BSK1kKLQ.js → fp_diff-7S8NcKIY.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-BuZNr-FE.js";
+import { r as runDiff, s as printResult } from "./runners-b1tgLA1B.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_diff.ts

package/build/{fp_explain-CrFcMeXU.js → fp_explain-C4X_-Rp7.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-BuZNr-FE.js";
+import { i as runExplain, s as printResult } from "./runners-b1tgLA1B.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, args } from "@adonisjs/core/ace";
 //#region commands/fp_explain.ts

package/build/{fp_inventory-B4Pv8Thz.js → fp_inventory-BJlIoetL.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-BuZNr-FE.js";
+import { a as runInventory, s as printResult } from "./runners-b1tgLA1B.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_inventory.ts

package/build/{fp_metrics-DoS5riGr.js → fp_metrics-BDKaNL0B.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-BuZNr-FE.js";
+import { o as runMetrics, s as printResult } from "./runners-b1tgLA1B.js";
 import { n as printerFor, t as __decorate } from "./decorate-D6enDn9D.js";
 import { BaseCommand, flags } from "@adonisjs/core/ace";
 //#region commands/fp_metrics.ts

package/build/index.js

@@ -2,5 +2,5 @@ import { configure } from "./configure.js";
 import { a as AEP_FACTORS, c as IncomparableSourcesError, f as defineConfig, i as measureStructure, l as SISP_FACTORS, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
 import "./src/types.js";
 import { n as ignoreCalls, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-CneCj3sT.js";
-import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-DqPrDZfD.js";
+import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-4sZBYGKU.js";
 export { AEP_FACTORS, BUILTIN_CALL_RESOLVERS, CoverageTooLowError, DEFAULT_TECHNICAL_PATTERNS, FACTOR_PRESETS, IncomparableRulesetsError, IncomparableSourcesError, RULESET, RULESET_VERSION, SISP_FACTORS, analyze, calibrate, configure, defineConfig, diffCounts, ignoreCalls, measureConformance, measureStructure, parseSamples };

package/build/{pipeline-DqPrDZfD.js → pipeline-4sZBYGKU.js}

@@ -2168,7 +2168,7 @@ function readPages(deliveries, env) {
 		for (const { store } of readable) {
 			if (reading.columns.has(store) || reading.unreadable.has(store)) continue;
 			const members = [...reading.unknownMembers.get(store) ?? []];
-			markUnreadable(reading, store, members.length > 0 ? `page "${page}" reads ${members.slice(0, 4).map((m) => `\`${m}\``).join(", ")} off ${store}, none of them a column of it` : `page "${page}" never reads ${store}`);
+			markUnreadable(reading, store, members.length > 0 ? `page "${page}" reads ${members.slice(0, 4).map((m) => `\`${m}\``).join(", ")} off ${store}, none of them a column of it` : `handed to page "${page}", and nothing the reader can see uses ${store}: every column counted, in the open`);
 		}
 	}
 	return reading;
@@ -3065,6 +3065,59 @@ function createAnalyzer(app, stores, options = {}) {
 			}
 			return found.size === 1 ? [...found][0] : null;
 		};
+		/**
+		* `await db.transaction(async (trx) => { … return … })` — also `Model.transaction`
+		* and `trx.transaction` (a savepoint): a body whose VALUE is what it returns. The
+		* callback's own locals are bound first, in source order, so `return { row: created }`
+		* can be read; then every return names one store, or nothing binds (plan 0.10 §B).
+		*/
+		const transactionCallbackOf = (call) => {
+			const callee = call.getExpression();
+			if (!Node.isPropertyAccessExpression(callee) || callee.getName() !== "transaction") return null;
+			return call.getArguments().find((a) => Node.isArrowFunction(a) || Node.isFunctionExpression(a)) ?? null;
+		};
+		const returnsOf = (callback) => {
+			if (!Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) return [];
+			const callbackBody = callback.getBody();
+			if (!Node.isBlock(callbackBody)) return [callbackBody];
+			const returned = [];
+			for (const statement of callbackBody.getDescendantsOfKind(SyntaxKind.ReturnStatement)) {
+				const owner = statement.getFirstAncestor((n) => Node.isArrowFunction(n) || Node.isFunctionExpression(n) || Node.isFunctionDeclaration(n) || Node.isMethodDeclaration(n));
+				const expression = statement.getExpression();
+				if (owner === callback && expression) returned.push(expression);
+			}
+			return returned;
+		};
+		const bindCallbackLocals = (callback) => {
+			for (const declaration of callback.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+				const nameNode = declaration.getNameNode();
+				const initializer = declaration.getInitializer();
+				if (!initializer || !Node.isIdentifier(nameNode)) continue;
+				const store = storeOfValue(initializer);
+				if (store) symbols.set(nameNode.getText(), store);
+			}
+		};
+		/** the store every return of the callback names — whole, or under one key of a returned literal */
+		const transactionValueStore = (callback, key) => {
+			bindCallbackLocals(callback);
+			const returned = returnsOf(callback);
+			if (returned.length === 0) return null;
+			const found = /* @__PURE__ */ new Set();
+			for (const expression of returned) {
+				let value = unwrapAwait(expression);
+				if (key) {
+					if (!Node.isObjectLiteralExpression(value)) return null;
+					const property = value.getProperty(key);
+					if (!property) return null;
+					value = Node.isPropertyAssignment(property) ? property.getInitializer() : Node.isShorthandPropertyAssignment(property) ? property.getNameNode() : void 0;
+					if (!value) return null;
+				}
+				const store = storeOfValue(value);
+				if (!store) return null;
+				found.add(store);
+			}
+			return found.size === 1 ? [...found][0] : null;
+		};
 		const isAuthUser = (node) => {
 			if (!authUserStore) return false;
 			const chain = Node.isCallExpression(node) ? node.getExpression() : node;
@@ -3097,6 +3150,8 @@ function createAnalyzer(app, stores, options = {}) {
 			if (Node.isPropertyAccessExpression(node)) return storeOfExpression(node, symbols, relationsByStore);
 			if (Node.isCallExpression(node)) {
 				const callee = node.getExpression();
+				const callback = transactionCallbackOf(node);
+				if (callback) return transactionValueStore(callback);
 				if (Node.isPropertyAccessExpression(callee)) {
 					/**
 					* `q.forUpdate()`, `q.where(…)`: a query-builder chain hands the same rows on —
@@ -3144,6 +3199,14 @@ function createAnalyzer(app, stores, options = {}) {
 					*/
 					const store = storeOfValue(initializer);
 					if (store) symbols.set(nameNode.getText(), store);
+				} else if (Node.isObjectBindingPattern(nameNode)) {
+					const call = unwrapAwait(initializer);
+					const callback = Node.isCallExpression(call) ? transactionCallbackOf(call) : null;
+					if (!callback) return;
+					for (const element of nameNode.getElements()) {
+						const store = transactionValueStore(callback, element.getPropertyNameNode()?.getText() ?? element.getName());
+						if (store) symbols.set(element.getName(), store);
+					}
 				}
 				return;
 			}
@@ -4194,8 +4257,15 @@ function isUnreadableWrite(call, symbols, imports, packageImports, body) {
 		const nameNode = declaration.getNameNode();
 		if (!Node.isIdentifier(nameNode) || nameNode.getText() !== root) continue;
 		const initializer = declaration.getInitializer();
-		const origin = initializer ? rootSymbolOf(unwrapAwait(initializer)) : null;
-		if (origin && packageImports.has(origin)) return false;
+		const initialized = initializer ? unwrapAwait(initializer) : null;
+		/**
+		* `await db.transaction(async (trx) => …)` is rooted at a package too, but its value
+		* is what the CALLBACK returns — the application's. Only a call with no function
+		* argument is a package's own object.
+		*/
+		const handsBackACallback = initialized && Node.isCallExpression(initialized) && initialized.getArguments().some((a) => Node.isArrowFunction(a) || Node.isFunctionExpression(a));
+		const origin = initialized ? rootSymbolOf(initialized) : null;
+		if (origin && packageImports.has(origin) && !handsBackACallback) return false;
 	}
 	return true;
 }
@@ -5142,13 +5212,14 @@ const RULESET = "afp";
 * the guard's user, a service the container made — and a write nobody can type is
 * an unresolved call instead of silence. Two in 1.8.0: a method the model
 * declares names the store its caller writes, and a listener written inline on a
-* string event is followed like a listener class.
+* string event is followed like a listener class. One in 1.9.0: the value of a
+* transaction callback is what its returns name.
 *
 * Without the bump, a baseline saved by the previous version compares cleanly
 * against this one and bills the tool's own improvement as work done. The guard
 * exists for exactly that, and only this constant arms it.
 */
-const RULESET_VERSION = "1.8.0";
+const RULESET_VERSION = "1.9.0";
 function count(input, options = {}) {
 	const warnings = [];
 	const usage = usageOf(input);
@@ -5296,7 +5367,7 @@ function unreadableDeliveryWarnings(input) {
 	if (blind.length === 0) return [];
 	return [
 		`${blind.length} transaction(s) deliver a value the analysis cannot read — a generated document, a call nobody followed — counted as 1 DET each, a FLOOR. This UNDERSTATES the output:`,
-		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.trigger} ${entry.signature}: ${behavior.delivered.opaqueFields.join(", ")}`),
+		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.identity}: ${behavior.delivered.opaqueFields.join(", ")}`),
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }
@@ -5312,7 +5383,7 @@ function unreadablePageWarnings(input) {
 	for (const entry of input.entryPoints) {
 		const behavior = input.behaviors.get(entry.id);
 		if (!behavior || behavior.writes) continue;
-		for (const [store, reason] of Object.entries(behavior.unreadablePages ?? {})) lines.push(`  ${entry.trigger} ${entry.signature}: ${store} leaves whole — ${reason}`);
+		for (const [store, reason] of Object.entries(behavior.unreadablePages ?? {})) lines.push(`  ${entry.identity}: ${store} leaves whole — ${reason}`);
 	}
 	if (lines.length === 0) return [];
 	return [
@@ -5446,7 +5517,7 @@ function unreadableInputWarnings(input) {
 	if (blind.length === 0) return [];
 	return [
 		`${blind.length} transaction(s) read the request without enumerating fields (\`all()\`, \`body()\`, \`except()\`), so their input DETs could not be counted and each sits at the floor of its band. This UNDERSTATES the total — the fix is a validator, not a configuration:`,
-		...blind.slice(0, 10).map(({ entry }) => `  ${entry.trigger} ${entry.signature}`),
+		...blind.slice(0, 10).map(({ entry }) => `  ${entry.identity}`),
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }
@@ -5467,7 +5538,7 @@ function unreadableOutputWarnings(input) {
 	if (blind.length === 0) return [];
 	return [
 		`${blind.length} transaction(s) pass through a transformer that spreads something the analysis cannot read, counted as 1 DET each — a FLOOR. This UNDERSTATES the output; the fix is in the transformer (\`this.pick(...)\` or named keys), not a configuration:`,
-		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.trigger} ${entry.signature}: ${behavior.opaqueOutputFields.join(", ")}`),
+		...blind.slice(0, 10).map(({ entry, behavior }) => `  ${entry.identity}: ${behavior.opaqueOutputFields.join(", ")}`),
 		...blind.length > 10 ? [`  … and ${blind.length - 10} more`] : []
 	];
 }

package/build/{runners-BuZNr-FE.js → runners-b1tgLA1B.js}

@@ -1,6 +1,6 @@
 import { c as IncomparableSourcesError, d as DEFAULTS, f as defineConfig, i as measureStructure, n as parseSamples, o as FACTOR_PRESETS, r as measureConformance, s as IncomparableRulesetsError, t as calibrate, u as diffCounts } from "./calibration-DVIf8hcE.js";
 import { y as toPosix } from "./resolvers-CneCj3sT.js";
-import { n as analyze } from "./pipeline-DqPrDZfD.js";
+import { n as analyze } from "./pipeline-4sZBYGKU.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";

package/build/src/albrecht/counter.d.ts

@@ -46,13 +46,14 @@ export declare const RULESET = "afp";
  * the guard's user, a service the container made — and a write nobody can type is
  * an unresolved call instead of silence. Two in 1.8.0: a method the model
  * declares names the store its caller writes, and a listener written inline on a
- * string event is followed like a listener class.
+ * string event is followed like a listener class. One in 1.9.0: the value of a
+ * transaction callback is what its returns name.
  *
  * Without the bump, a baseline saved by the previous version compares cleanly
  * against this one and bills the tool's own improvement as work done. The guard
  * exists for exactly that, and only this constant arms it.
  */
-export declare const RULESET_VERSION = "1.8.0";
+export declare const RULESET_VERSION = "1.9.0";
 export type CountInput = {
     app: AppContext;
     stores: CollectedDataStore[];

package/build/src/cli.js

@@ -1,5 +1,5 @@
-import { t as CoverageTooLowError } from "../pipeline-DqPrDZfD.js";
-import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-BuZNr-FE.js";
+import { t as CoverageTooLowError } from "../pipeline-4sZBYGKU.js";
+import { a as runInventory, c as ConfigLoadError, i as runExplain, n as runCount, o as runMetrics, r as runDiff, s as printResult, t as runCalibrate } from "../runners-b1tgLA1B.js";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/build/src/pipeline.js

@@ -1,2 +1,2 @@
-import { n as analyze, t as CoverageTooLowError } from "../pipeline-DqPrDZfD.js";
+import { n as analyze, t as CoverageTooLowError } from "../pipeline-4sZBYGKU.js";
 export { CoverageTooLowError, analyze };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@filipebraida/adonis-function-points",
   "description": "Automated function point counting and code metrics for AdonisJS applications.",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "engines": {
     "node": ">=24.0.0"
   },