@filipebraida/adonis-function-points 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -6,6 +6,176 @@ 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.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
+by counting real applications function by function against what a certified counter
+would write down — and every one was frozen in a fixture with a hand-written reference
+**before** the code. A 0.5.0 baseline has to be recounted; on the three applications
+this release was reviewed against the totals move −18, −8 and −37 FP, and the whole
+of it is EOs losing DETs they never showed and one data function that was four.
+
+### Counting
+
+- **An output's DETs are what leaves the boundary, not every column read.** A
+  transformer decides the output of the store it is FOR (`BaseTransformer<X>`, and the
+  resources of the transformers nested in it): the keys the reached method returns, a
+  nested transformer's keys once, `this.pick([...])` by name, `xs.map(...)` as a
+  repeating group. For every other store touched, what leaves is what the code shows:
+  rows whole (every column), the columns a `.select()` names, or **one derived scalar**
+  for `.count()` / `.exists()`. A relation preloaded through a covered store and read
+  no other way is covered too — it was loaded for the transformer. A spread the walker
+  cannot read counts 1 DET as a floor and is reported, like an open input object.
+  Before, a detail page through three transformers came out at 67 DET; a dashboard of
+  eight counters at 84.
+- **A system timestamp is not a DET.** `autoCreate` / `autoUpdate` say the framework
+  stamps the column; the user neither supplies nor recognises it — the ground the key
+  was already excluded on. Excluded on the data function, on every output, and on a
+  transformer that re-emits it. A `dateTime` the user sets still counts. AFP §7.2 on
+  its letter would count both; the departure is now consistent, and counting-decisions
+  §6 says so.
+- **A column declared `serializeAs: null` never leaves.** Lucid does not serialise it,
+  so it is not an output DET however the store leaves. It stays a DET of the data
+  function. Found as `User.password` on an activity log's output.
+- **A detail the user only sees inside its master is a RET, not a data function.** A
+  `hasMany` / `hasOne` child that no application code addresses directly — only
+  `related()` / `preload()` from the parent — folds into the parent: one ILF with N RET,
+  the child's link to the parent excluded from the DETs, one FTR for a transaction
+  touching both. A child with a query of its own stays its own file (the Vazquez
+  benchmark depends on it); a child hanging off two parents stays apart and the report
+  says why. Cascade delete was measured and rejected as the signal: on one application
+  11 of 13 cascades pointed at the tenant table. On the three applications the rule
+  folds four stores in all — the `Inpi*` mirror of an external registry becomes **one**
+  EIF with 4 RET, which is what the CPM says.
+- **A data function is identified by its table**, as counting-decisions §5 always said.
+  Keyed by the class, renaming a model billed as a deletion plus an addition.
+- **A token table is technical.** `password_reset_tokens`, `auth_access_tokens`,
+  `remember_me_tokens` are the machinery of authentication; `.*tokens?.*` joins the
+  naming list. And the list is now configurable in fact — `boundary.technicalPatterns`
+  replaces it, `DEFAULT_TECHNICAL_PATTERNS` is exported to start from — as §4 and the
+  filter's own comment had claimed since 0.1.0 while `counter.ts` passed nothing.
+
+### Configuration
+
+- **`opaque.<Store.column | validator.field>`** replaces `overrides.<fn>.detFromSchema`
+  and `overrides.<fn>.opaqueReviewed`. A declaration about a DET the analysis cannot read
+  is about the column or the validator field — its ORIGIN — and applies to every
+  function that carries it: the ILF, the transaction that submits it, each screen that
+  shows it. Read from a real configuration, the old shape had the same mapping written
+  twice and a `GET` returning the same column still at 1 DET: the same column worth two
+  numbers in one count. Reviews are matched exactly; matched by bare name, reviewing
+  `Message.schema` reviewed every `schema` column of every store. A column may be keyed
+  by model or by table. The two old keys are gone from the type — an old configuration
+  fails to typecheck — and, because a configuration file is loaded without types,
+  `fp:count` still tells one that carries them that they had no effect.
+  `overrides.<fn>.det` / `.refs` remain per function.
+- **`dataFunctions.grouping: 'usage' | 'none'`** replaces `retStrategy`. `none` is the
+  0.5.0 behaviour — every table its own data function at RET 1 — for comparing with an
+  old count; it is not a preference. `retStrategy` is gone from the type, and `fp:count`
+  says so when an untyped configuration still carries it.
+- **`boundary.technicalPatterns`**, see above.
+
+### New
+
+- **The count names what it cannot decide.** Two transactions of the same type that
+  reach the same stores, emit the same DETs and walk the same bodies below the
+  controller are reported as look-alikes with the FP at stake — the CPM counts
+  identical processing logic once, and `boundary.ignoreEntryPoints` records the
+  decision. An EIF only a seeder writes is reported too: code data the team maintains
+  is not counted, a mirror of another system's data is a legitimate EIF, and the code
+  cannot tell which. Neither moves a number (counting-decisions §11).
+- **`diff.preset: 'sisp'`** prices change by the Roteiro de Métricas de Software do SISP
+  v3.0 (Portaria SGD/MGI nº 3656/2026), §7.3 — inclusão 1,00, alteração × FI 0,63 (the
+  contractor maintains its own work; 0,84 otherwise, via `factors`), exclusão 0,50 —
+  instead of AEP. `fp:diff` prints which preset produced the billable total. Read from
+  the guide's PDF: a first draft of this preset said 0,50 / 0,30 from memory, and v2.0
+  (2012) priced exclusion at 0,40 — a contract binds to a revision, so check yours.
+- **`ignoreCalls({ name, methods | matching })`** builds a "this reaches no data"
+  strategy without the ceremony a real configuration had to carry — a helper to read
+  the method name off a ts-morph node, a `resolve` that returns nothing, one comparison.
+  The strategy is still named, and its volume is still reported.
+- The configuration stub no longer echoes defaults.
+
+### Documented
+
+- counting-decisions §6 now describes what the code does for output DETs, row by row,
+  and records the two refinements the recounts forced; §4 says plainly that only the
+  naming mechanism of the technical filter exists, and why the lookup-structure rule
+  was rejected; §9 gains "Declared by origin, not by function"; §10 is the master-detail
+  rule, with the cascade measurement that rejected the structural signal; §11 is what
+  the count reports because it cannot decide.
+- Five reference fixtures were written before their rules: `transformed_output` (59 FP,
+  eight output shapes), `system_timestamps` (18), `mestre_detalhe` (41; 51 with
+  grouping off), and additions to `edges_boundary` and `open_object`.
+
 ## 0.5.0
 
 **Rule set `afp@1.4.0`.** Two classification defects are fixed and both move numbers,