@filipebraida/adonis-function-points 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -6,6 +6,144 @@ 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.8.0
+
+**Rule set `afp@1.7.0`.** One rule, wide, found by a team reviewing a 0.6.0 count of
+their own application: six transactions that write were counted as EOs, with the
+coverage at 99.5% and three unresolved calls. The number was close and the count was
+wrong in nine places, and only the coverage line could have said so — it said 100%.
+Frozen in a fixture with a hand-written reference before the code, recounted on the
+three validated applications. A 0.7.0 baseline has to be recounted: the totals move −1,
+−8 and +2 FP; what moves is EO → EI (3 / 11 / 2 transactions), FTRs gained, and a
+coverage that now falls where the analysis does not know.
+
+### Fixed
+
+- **A write binds to what the variable IS, not to where it was born.** `document.save()`
+  was a write on `Document` only when the instance was born in the same body or arrived
+  as a parameter typed inline. The reviewed application's dominant shape — the
+  controller loads, the action alters — arrives it destructured from a **named**
+  interface (`handle({ document, name }: RenameDocumentInput)`), by `const { x } =
+input`, as a followed method's **declared return type** (`Promise<Session | null>`;
+  unannotated, its `return`s when every one is a store, one level of calls down), as a
+  conditional or a default whose branches are the same store (`id ? await X.find(id) :
+new X()`, `(await q.first()) ?? new X()`), as `auth.user` / `auth.getUserOrFail()` —
+  the model `config/auth.ts` names in its provider, read, never assumed — as a
+  **relation read off a loaded row** (`const pasta = documento.pasta`, which had been
+  billed to `Documento`), as a `for…of` or a callback parameter over rows or a relation,
+  as a `let x: Store` assigned later, as `Store[]` or `Store | null` parameters. Every
+  one is a reading of what the code declares; no type checker (the project resolves no
+  `#alias/…`, so `getType()` is `any`), and no guess. Counting-decisions §3.
+- **A write on a receiver nobody can type is an UNRESOLVED call**, reason "write on a
+  receiver whose type the analysis cannot read": `x.save()` / `x.delete()` with no
+  arguments, `x.merge(…).save()`, `x.related('…').create|sync|attach(…)`. It lowers
+  coverage and is listed by `fp:inventory`; the transaction stays what the readable
+  code says. A local a package built (`await PDFDocument.create()`, then `pdf.save()`)
+  is not a store and is not reported. This is the line between a count that errs and a
+  count that lies, and it did not exist.
+- **A service is what the container returns.** `const svc = await
+app.container.make(X)` binds `svc` to X as `new X()` already did, so `svc.method()` is
+  followed. On the reviewed application this shape carried the write of
+  `POST /gestao/atribuicao` and 31 more sites.
+- A method chain on store rows handed to a delivery (`rows.map(f).join('\n')`) delivers
+  the rows, not one field.
+
+### New
+
+- **What the page shows is what leaves**, for a store handed to the page raw — no
+  transformer, no `.select()`. `inertia.render('livros/index', …)` opens
+  `inertia/pages/livros/index.tsx` (or `app/<module>/ui/pages/…`, or any `pages/` directory
+  — exactly one match, or nothing is read) and `view.render('catalogo')` opens
+  `resources/views/catalogo.edge`; the columns the page reads off the rows are the DETs
+  (`page:Livro.titulo`), one child component deep, through tsconfig `paths`, subpath
+  imports and relative paths. Where it cannot read — a second level of components, a
+  spread, a function receiving the rows, a package's `<DataTable data={…} />`, two files
+  answering to one name, one prop carrying several stores, members that are not columns
+  — the store leaves whole and the count says why, by transaction. Measured on the three
+  applications: **0 FP moved** (sae: three pages read, 22 stores reported; the other two
+  hand every raw store through a transformer). Fixture `inertia_pages` (25 FP): the DETs
+  change, the points do not.
+
+### Documented
+
+- counting-decisions §3 gains "A write is attributed to what the variable IS", with the
+  eleven bindings as a table; the fixture `escritas_indiretas` (87 FP; `afp@1.6.0` said
+  57 with full coverage — five EIs sold as EOs, two ILFs mistaken for EIFs, one ILF lost)
+  carries one transaction per shape, plus the unreadable receiver and the package object.
+- counting-decisions §6 gains "What the page shows" — the reader, its reach, and the
+  measured zero.
+- The three boundary questions the review left open — technical logs, a mirror of another
+  system's table, a requirement's data — are declarations (`boundary.infrastructure`,
+  `boundary.externallyMaintained`), not rules; plan 0.8 §C records them.
+
+## 0.7.0
+
+**Rule set `afp@1.6.0`.** Three rules move the number for unchanged code, every one
+frozen in a fixture with a hand-written reference before the code, and every one
+recounted on the three validated applications function by function — four times for
+the first. A 0.6.0 baseline has to be recounted: the totals move −16, +8 and +21 FP,
+and most of that is new elementary processes the count had never seen.
+
+### Counting
+
+- **An output's DETs are what the transaction delivers.** The place an output crosses
+  the boundary is the delivery — the props of `inertia.render` / `inertia.modal` /
+  `view.render`, the payload of `response.json|ok|created|send`, what a command prints
+  — and each value delivered is read back to its origin: a followed call's classified
+  **return** (a key of it when destructured or picked: `const { data, meta } = …`,
+  `meta.pagina`), a store's columns when rows are handed on, a literal's leaves once, a
+  scalar as 1, an echoed input as 0 (it counted on entry, §7.3), and a value nobody can
+  read as 1, opaque, **reported by transaction**. A store read to authorise and
+  delivered by nothing stays an FTR and contributes no DET; a document built from rows
+  (`gerarCsv(produtos)`) carries the rows. A variant **replaces** `toObject()`; a
+  function of the same file and a function passed to `.map()` by reference are
+  followed; an echo stays an echo through `?? null` and `.toISOString()`;
+  `paginator.getMeta()` is four values; a literal with computed keys is one repeating
+  attribute; a yes/no, a formatted value, a framework service's answer and an Inertia
+  lazy prop are one value. Without a delivery point the output falls back to the
+  stores read, as before. On the applications: a home page at 1 DET became 10; a
+  petitions list at 8 DET became 60 — its nested transformers, which the unresolved
+  variant had hidden; every listing page stopped counting its filters twice.
+- **A function of the same file is followed** (`local-function`), and so is
+  `rows.map(paraLinha)`. Not only DETs: the stores those helpers read are FTRs now, and
+  two `POST`s that wrote through a local helper moved from EO to EI. Models and modules
+  imported **inside** a body (`const { default: X } = await import('#…')`) bind like a
+  static import — an importer that wrote four tables this way had touched nothing.
+- **An ace command is an elementary process.** `commands/**` extending `BaseCommand`
+  with a literal `static commandName` is an entry point (`ace <commandName>`, §5); its
+  body is `run()`, its input DETs the `@flags.*` / `@args.*` declared, by the name the
+  operator types; what it prints (`this.ui.table().row(…)`, `this.logger.info(…)`) is
+  its output, read by the same classifier. One that reaches no store is no transaction.
+  Every counted command is **listed with its FP**, a file importing `@faker-js/faker`
+  carries the hint "generates data, probably a development tool", and
+  `boundary.ignoreEntryPoints: ['<commandName>']` records the decision — the CPM does
+  not count the team's tools, and the code cannot tell a generator from an importer.
+
+### New
+
+- **A job no transaction reaches is reported, never counted**: "scheduled from
+  start/scheduler.ts, outside every transaction", "dispatched from app/…/service.ts,
+  which no transaction reaches", or "dispatched by nothing in the application". A
+  scheduled process is an elementary process nobody is counting; inventing one is the
+  error this package exists to avoid, so it becomes an entry point only once a
+  scheduler is read as a source (counting-decisions §9).
+- The `transform` before a `useVariant` is claimed and followed nowhere, instead of
+  falling to `static-service` and being reported as a package method with no body —
+  which is what every variant chain had been doing to the unresolved count.
+
+### Documented
+
+- counting-decisions §6 gains the delivery table and the eleven-row table of how a
+  delivered value is read back to its origin; §5 says how a command's identity is
+  rendered; §9 gains "A job no transaction reaches is reported, never counted".
+- Two reference fixtures written before their rules: `render_props` (62 FP, thirteen
+  shapes of delivery, one added per recount) and `ace_commands` (26 FP; the previous
+  rule set said 9 — the table only commands maintain looked like an EIF); a pattern
+  fixture `local_function` for the resolver.
+- Reading the page (`.tsx` / `.edge`) for what it shows of a raw prop — plan 0.7 §B —
+  is deferred to 0.8, as the plan allowed: the delivery rule made it a refinement of one
+  case, and the recounts spent the release on the cases that moved numbers.
+
 ## 0.6.0
 
 **Rule set `afp@1.5.0`.** Six rules change what a number is made of, all of them found

package/README.md

@@ -13,7 +13,7 @@ node ace fp:count
 
 ```
 Unadjusted count: 46 FP
-Ruleset: afp@1.5.0
+Ruleset: afp@1.7.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-C43fU39x.js")
+		importer: () => import("../fp_inventory-B322MvZT.js")
 	},
 	{
 		commandName: "fp:metrics",
-		importer: () => import("../fp_metrics-DEMPk4xC.js")
+		importer: () => import("../fp_metrics-DjADb7F6.js")
 	},
 	{
 		commandName: "fp:count",
-		importer: () => import("../fp_count-CZ0cUUBQ.js")
+		importer: () => import("../fp_count-B_KPNKMO.js")
 	},
 	{
 		commandName: "fp:explain",
-		importer: () => import("../fp_explain-D6QvDLKQ.js")
+		importer: () => import("../fp_explain-C2s6Kpaj.js")
 	},
 	{
 		commandName: "fp:diff",
-		importer: () => import("../fp_diff-BTg_LX0r.js")
+		importer: () => import("../fp_diff-B3NhXzrb.js")
 	},
 	{
 		commandName: "fp:calibrate",
-		importer: () => import("../fp_calibrate-EAuAtdbq.js")
+		importer: () => import("../fp_calibrate-B_oD9b02.js")
 	}
 ];
 let cache = null;

package/build/{fp_calibrate-EAuAtdbq.js → fp_calibrate-B_oD9b02.js}

@@ -1,4 +1,4 @@
-import { s as printResult, t as runCalibrate } from "./runners-FYmPIPub.js";
+import { s as printResult, t as runCalibrate } from "./runners-BpBJsGMj.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-CZ0cUUBQ.js → fp_count-B_KPNKMO.js}

@@ -1,4 +1,4 @@
-import { n as runCount, s as printResult } from "./runners-FYmPIPub.js";
+import { n as runCount, s as printResult } from "./runners-BpBJsGMj.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-BTg_LX0r.js → fp_diff-B3NhXzrb.js}

@@ -1,4 +1,4 @@
-import { r as runDiff, s as printResult } from "./runners-FYmPIPub.js";
+import { r as runDiff, s as printResult } from "./runners-BpBJsGMj.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-D6QvDLKQ.js → fp_explain-C2s6Kpaj.js}

@@ -1,4 +1,4 @@
-import { i as runExplain, s as printResult } from "./runners-FYmPIPub.js";
+import { i as runExplain, s as printResult } from "./runners-BpBJsGMj.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-C43fU39x.js → fp_inventory-B322MvZT.js}

@@ -1,4 +1,4 @@
-import { a as runInventory, s as printResult } from "./runners-FYmPIPub.js";
+import { a as runInventory, s as printResult } from "./runners-BpBJsGMj.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-DEMPk4xC.js → fp_metrics-DjADb7F6.js}

@@ -1,4 +1,4 @@
-import { o as runMetrics, s as printResult } from "./runners-FYmPIPub.js";
+import { o as runMetrics, s as printResult } from "./runners-BpBJsGMj.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

@@ -1,6 +1,6 @@
 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-DlKJOZnk.js";
-import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-Cq4dNTNE.js";
+import { n as ignoreCalls, t as BUILTIN_CALL_RESOLVERS } from "./resolvers-DhJO-qvQ.js";
+import { a as DEFAULT_TECHNICAL_PATTERNS, i as RULESET_VERSION, n as analyze, r as RULESET, t as CoverageTooLowError } from "./pipeline-C6kHKB9-.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 };