@ti-engine/web-framework 1.25.0 → 1.25.1

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 This document will contain the list of changes made to the framework. The format is based on the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
 
+## Version 1.25.1
+
+* fix(ti-framework): resolve a label key whose own name contains a literal dot. `getLabel` split the key on every
+  dot and descended one object level per segment, so a group storing flat dotted keys — because the key IS a dotted
+  path in the consuming application's domain, e.g. audit-log field labels keyed by employee field path
+  (`"personal.workSite"`, `"career.roleFamily"`) — could never be reached. The miss was silent: the caller's
+  fallback rendered instead, which is why competence's Employee Management audit tab had shown every changed field
+  as its raw field path for as long as those labels have existed. Resolution now tries the longest literal key that
+  matches at each level, shortens a segment at a time, and backtracks when a matched branch turns out not to hold
+  the rest of the key — so a purely nested catalogue resolves exactly as before, a literal dotted key wins over the
+  nested path of the same name, and a genuinely absent key still returns the fallback
+* test(ti-framework): cover `tiApplication.getLabel` against the store the browser actually gets. `ti-framework.js`
+  is a plain browser script with no module exports, so `test/helpers/ti-framework-sandbox.js` loads it in a Node
+  sandbox, fires `alpine:init` and hands back the registered stores — exercising the shipped resolver rather than
+  asserting against its source text, which is what let this defect sit unnoticed
+
 ## Version 1.25.0
 
 * feat(config-management): surface a `driftTracked` flag on the `getDrift` / `listDrift` payloads, defaulting to

package/bin/static/scripts/ti-framework.js

@@ -800,27 +800,69 @@ const configureApplication = () => {
     const tiToolbox = Alpine.store( "tiToolbox" );
 
     /**
-     * Used to extract a label from a nested labels object.
+     * Marker returned by {@link resolveLabel} when a key is not present in the labels object. A dedicated sentinel
+     * rather than `undefined` so that backtracking can never be confused by a stored value.
+     *
+     * @constant
+     * @private
+     */
+    const LABEL_NOT_FOUND = Object.freeze( {} );
+
+    /**
+     * Resolves a label key against a labels object, trying the longest literal key that matches at each level and
+     * shortening on a miss.
+     * <br/>
+     * A labels catalogue is not always purely nested: a group may store flat keys that themselves contain a dot,
+     * because the key IS a dotted path in the application's own domain — competence keys its audit-log field labels
+     * by employee field path ("personal.workSite", "career.roleFamily"). Descending exactly one object level per dot
+     * can never reach those, and the miss is silent: the caller's fallback renders instead. So each level tries the
+     * whole remaining key first, shortens a segment at a time, and backtracks whenever a matched branch turns out
+     * not to hold the rest of the key.
      *
      * @method
      * @param {Object} labels
      * @param {String[]} keys
-     * @param {String} fallback
-     * @returns {String}
+     * @returns {String|Object} The resolved value, or {@link LABEL_NOT_FOUND}.
      * @private
      */
-    const extractLabel = ( labels, keys, fallback ) => {
-        let key = keys.shift();
-        if ( labels && typeof labels === "object" && key && Object.prototype.hasOwnProperty.call( labels, key ) ) {
+    const resolveLabel = ( labels, keys ) => {
+        if ( !labels || typeof labels !== "object" || keys.length === 0 ) {
+            return LABEL_NOT_FOUND;
+        }
+        for ( let length = keys.length; length > 0; length-- ) {
+            const key = keys.slice( 0, length ).join( "." );
+            if ( !Object.prototype.hasOwnProperty.call( labels, key ) ) {
+                continue;
+            }
             const value = labels[ key ];
+            const remainder = keys.slice( length );
             if ( typeof value === "string" ) {
-                return keys.length === 0 ? value : fallback;
-            }
-            if ( value && typeof value === "object" ) {
-                return extractLabel( value, keys, fallback );
+                if ( remainder.length === 0 ) {
+                    return value;
+                }
+            } else if ( value && typeof value === "object" ) {
+                const resolved = resolveLabel( value, remainder );
+                if ( resolved !== LABEL_NOT_FOUND ) {
+                    return resolved;
+                }
             }
         }
-        return fallback;
+        return LABEL_NOT_FOUND;
+    };
+
+    /**
+     * Used to extract a label from a nested labels object.
+     *
+     * @method
+     * @param {Object} labels
+     * @param {String[]} keys
+     * @param {String} fallback
+     * @returns {String}
+     * @private
+     */
+    const extractLabel = ( labels, keys, fallback ) => {
+        const resolved = resolveLabel( labels, keys );
+        return ( typeof resolved === "string" ) ? resolved : fallback;
     };
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ti-engine/web-framework",
-  "version": "1.25.0",
+  "version": "1.25.1",
   "description": "A web-framework based on the ti-engine. It provides a customizable ready-to-use web-server microservice and a set of tools for creating web applications. NOTICE: This is still a work in progress and the full architecture, design, and functionality are not available!",
   "keywords": [
     "ti-engine",