@nmakarov/cli-toolkit 0.36.0 → 0.39.0

package/dist/cli-runner.js

@@ -1863,11 +1863,14 @@ var Params = class _Params {
    * Attribution rules:
    *   - entries figured from an explicit input (cli/env/options/…) are left
    *     untouched — the component merely confirmed them, the origin stands;
-   *   - entries whose source is "default" (Params had nothing) are upgraded
-   *     in place to the reported value and source;
+   *   - "default" entries (Params had nothing) and earlier reports are
+   *     replaced by the report;
    *   - keys never seen by Params are appended as new entries.
-   * First report wins: once upgraded, later reports for the same key/module
-   * are ignored (the source is no longer "default").
+   * The LATEST report wins — a component may resolve the same key several
+   * times with increasing specificity (e.g. a blueprint re-merged for a
+   * concrete resource) and the dump should show what it settled on.
+   * Later params.get() probes that find nothing ("default") never shadow a
+   * reported value — see {@link getFiguredByModule}.
    *
    * @param {string} key
    * @param {*} value - the value the component actually uses
@@ -1877,17 +1880,20 @@ var Params = class _Params {
   reportResolved(key, value, source = "discovered", moduleName) {
     const mod = moduleName ?? this._currentModule;
     const mine = this.trackedParams.filter((e) => e.key === key && e.module === mod);
-    if (mine.some((e) => e.source !== "default")) {
+    if (mine.some((e) => e.source !== "default" && !e.reported)) {
       return;
     }
-    if (mine.length === 0) {
-      this.trackParam(key, "reported", value, source, mod);
-      return;
-    }
-    for (const entry of mine) {
-      entry.value = value;
-      entry.source = source;
-    }
+    this.trackedParams = this.trackedParams.filter(
+      (e) => !(e.key === key && e.module === mod)
+    );
+    this.trackedParams.push({
+      key,
+      definition: "reported",
+      value,
+      source,
+      module: mod,
+      reported: true
+    });
   }
   /**
    * Get all tracked parameters (for --stopAfter=init)
@@ -1913,12 +1919,24 @@ var Params = class _Params {
   /**
    * Get figured parameters grouped by module name.
    * Same param can appear in multiple modules (e.g. source, resource).
+   * Last occurrence per key wins, EXCEPT that an empty probe — a
+   * params.get() that found nothing ("default", undefined) — never shadows
+   * a value reported via {@link reportResolved}: components probe for
+   * overrides on every resolution cycle, and those misses say nothing about
+   * the value the component actually uses.
    */
   getFiguredByModule() {
+    const reported = /* @__PURE__ */ new Set();
+    for (const param of this.trackedParams) {
+      if (param.reported) reported.add(`${param.module}\0${param.key}`);
+    }
     const byModule = {};
     for (const param of this.trackedParams) {
       const mod = param.module;
       if (!byModule[mod]) byModule[mod] = {};
+      if (!param.reported && param.source === "default" && reported.has(`${mod}\0${param.key}`)) {
+        continue;
+      }
       byModule[mod][param.key] = { value: param.value, source: param.source };
     }
     return byModule;
@@ -3229,11 +3247,31 @@ var Db = class _Db {
     }
     this.queriesLog = [];
     this.knexInstance.queriesLog = this.queriesLog;
+    const startsByConnection = /* @__PURE__ */ new Map();
+    const pushStart = (query) => {
+      const uid = query?.__knexUid ?? "";
+      if (!startsByConnection.has(uid)) {
+        startsByConnection.set(uid, []);
+      }
+      startsByConnection.get(uid).push(process.hrtime());
+    };
+    const popStart = (query) => {
+      const uid = query?.__knexUid ?? "";
+      const stack = startsByConnection.get(uid);
+      if (!stack?.length) {
+        return null;
+      }
+      return stack.pop();
+    };
     this.knexInstance.on("query", (query) => {
-      query.__startTime = process.hrtime();
+      pushStart(query);
     });
     this.knexInstance.on("query-response", (_response, query) => {
-      const [seconds, nanoseconds] = process.hrtime(query.__startTime);
+      const start = popStart(query);
+      if (!start) {
+        return;
+      }
+      const [seconds, nanoseconds] = process.hrtime(start);
       const executionTimeMs = (seconds * 1e3 + nanoseconds / 1e6).toFixed(2);
       const logEntry = {
         sql: query.sql,
@@ -3244,6 +3282,7 @@ var Db = class _Db {
       this.logger.debug?.(`[Db] Query: ${query.sql} | Duration: ${executionTimeMs}ms`);
     });
     this.knexInstance.on("query-error", (error, query) => {
+      popStart(query);
       this.logger.error?.(`[Db] Query failed: ${query.sql}`, error);
     });
   }