@filipebraida/adonis-function-points 0.4.0 → 0.6.0

package/build/src/types.d.ts

@@ -45,6 +45,17 @@ export type Attribute = {
     name: string;
     type?: string;
     isIdentifier: boolean;
+    /**
+     * Maintained by the framework, not by the user: `autoCreate` / `autoUpdate`
+     * on a `@column.dateTime()`. Not a DET, on the same ground as the identifier —
+     * counting-decisions §6.
+     */
+    system?: boolean;
+    /**
+     * `serializeAs: null`: Lucid never serialises it, so it never leaves on an
+     * output. Still a DET of the data function — counting-decisions §6.
+     */
+    hidden?: boolean;
     provenance: Provenance;
 };
 /**
@@ -84,6 +95,8 @@ export type HandlerBehavior = {
     writes: boolean;
     /** DataStores reached (ids) */
     touches: string[];
+    /** of those, the ones this transaction writes — §6.5.4 is per store, not per request */
+    writtenStores: string[];
     /** declared input fields (validators) */
     inputFields: Field[];
     /**
@@ -103,8 +116,26 @@ export type HandlerBehavior = {
     requestFields: Field[];
     /** the transaction reads the request in a way that enumerates nothing */
     opaqueRequest: boolean;
-    /** declared output fields (transformers, DTOs) */
+    /**
+     * What a transformer on the path emits — counting-decisions §6. Empty means no
+     * transformer was reached and the output is counted from the stores' columns.
+     */
     outputFields: Field[];
+    /** output spreads the analysis could not read: 1 DET each, a floor */
+    opaqueOutputFields: Field[];
+    /** stores a transformer on the path is for: their keys leave, not their columns */
+    transformedStores: string[];
+    /**
+     * How each store was read: rows whole, `.select()` columns, or one aggregate
+     * scalar; by its own chain (`direct`) or preloaded through another store (`via`).
+     */
+    outputReads: Record<string, {
+        whole: boolean;
+        selected: string[];
+        aggregate: boolean;
+        direct: boolean;
+        via: string[];
+    }>;
     /** path walked through the call graph — what `fp:explain` prints */
     trace: TraceStep[];
     /** calls no resolver knew how to follow */

package/build/stubs/config.stub

@@ -24,31 +24,44 @@ export default defineConfig({
     business: [],
   },
 
-  /** Logical subgroups (RET). `constant` pins it at 1, which is honest. */
-  retStrategy: 'constant',
+  /**
+   * How tables fold into data functions (RET). `usage`, the default: a
+   * `hasMany`/`hasOne` child no application code addresses directly is a RET of
+   * its parent, not an ILF of its own. `none` keeps every table apart, at RET 1,
+   * to compare against a count made before 0.6.0.
+   */
+  // dataFunctions: { grouping: 'usage' },
 
-  /** How far to follow the call graph from the handler. */
-  maxDepth: 3,
+  /** How far to follow the call graph from the handler (default 3). */
+  // maxDepth: 3,
 
   /** Refuses to emit a count if tracing covers less than this. */
   minCoverage: 0.85,
 
   /**
-   * Facts static analysis cannot read, declared with a required justification.
-   *
-   * The case this exists for: fields the user fills that live in a JSON column
-   * whose schema is stored in the database. See counting-decisions §8 — and use
-   * it sparingly, because `fp:count` reports what share of the total came from
-   * here.
+   * DETs static analysis cannot read — a JSON column, an open validator field —
+   * count 1 each, a floor, and `fp:count` names them. Answer them here by ORIGIN,
+   * with a required justification, and the answer reaches every function carrying
+   * the DET. See counting-decisions §8; use it sparingly, because `fp:count`
+   * reports what share of the total came from here.
    */
-  // overrides: {
-  //   // one schema, or several whose fields are unioned by leaf path
-  //   Form: { detFromSchema: ['intakeSchema', 'reviewSchema'], reason: 'one per template' },
+  // opaque: {
+  //   // the fields live in a JSON Schema declared in the code: name it (or several,
+  //   // unioned by leaf path), and the count keeps coming from the code
+  //   'Survey.answers': { schemas: ['surveySchema', 'feedbackSchema'], reason: 'one schema per survey template' },
+  //   'answerSurveyValidator.answers': { schemas: 'surveySchema', reason: 'the same form, submitted' },
   //
   //   // 1 DET is a floor, and `fp:count` says so on every run. When 1 IS the right
-  //   // answer, record that someone checked — otherwise the warning becomes noise
-  //   // the team learns to scroll past. It moves no number.
-  //   Petition: { opaqueReviewed: ['schema', 'uiSchema'], reason: 'metadata; one field each' },
+  //   // answer, record that someone checked — it moves no number
+  //   'Attachment.metadata': { reviewed: true, reason: 'size and mime type: one bag, one field' },
+  // },
+
+  /**
+   * A declared NUMBER for one function — the last resort, for a schema that lives
+   * only in the database. It freezes: prefer `opaque.<origin>.schemas`.
+   */
+  // overrides: {
+  //   'POST /surveys/:id/answers': { det: 42, reason: 'the form has 42 fields, defined in the database' },
   // },
 
   /**

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.4.0",
+  "version": "0.6.0",
   "engines": {
     "node": ">=24.0.0"
   },