@peter.naydenov/fsm-hub 2.1.5 → 2.1.6

package/{Chaingelog.md → Changelog.md}

@@ -1,6 +1,14 @@
 ## Release History
 
 
+### 2.1.6 ( 2026-07-22)
+- [x] Fix: `_callback.js` crashed when a callback rule fired with a `null` response (or a transformer returning `null`). Guarded the `.answer` access so the placeholder-clear no-ops and the callback still runs.
+- [x] Fix: `MISSING_FSM` debugger call logged the whole subscribers array instead of the missing name. Now passes the specific missing entry.
+- [x] Tests: 3 regression cases added (1 for the `MISSING_FSM` data, 2 for the null-response crashes). 14 → 17 passing;
+- [x] Dev dependencies updates. @peter.naydenov/fsm - v.5.2.7;
+
+
+
 ### 2.1.5 ( 2026-07-21)
 - [x] Dependency update. ask-for-promise@3.2.0;
 - [x] Dev dependency update. @peter.naydenov/fsm - v.5.2.6;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@peter.naydenov/fsm-hub",
   "description": "FSM orchestration and state-managment tool",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "license": "MIT",
   "author": "Peter Naydenov",
   "main": "./dist/fsm-hub.umd.js",
@@ -26,7 +26,7 @@
     "ask-for-promise": "^3.2.0"
   },
   "devDependencies": {
-    "@peter.naydenov/fsm": "5.2.6",
+    "@peter.naydenov/fsm": "5.2.7",
     "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^1.0.0",

package/src/methods/_callback.js

@@ -17,10 +17,18 @@ return function _callback ( task, fsmName, state, response ) {
             return
         }
 
-    if ( fsmSubscriber ) {   // Execute fsm rules 
+    if ( fsmSubscriber ) {   // Execute fsm rules
             fsmSubscriber.forEach ( subscriberName => {
                                   if ( !hub.fsm[ subscriberName ] ) {
-                                          hub._debugger ( msg.MISSING_FSM, fsmSubscriber )
+                                          // Log the missing subscriber's name, not the
+                                          // whole subscribers array. The debugger formats
+                                          // the warning as `Warning: Fsm "%s" is not
+                                          // registered to the hub.` and the array makes
+                                          // the message look like
+                                          //   `... to the hub. [ 'two' ]`
+                                          // instead of the intended
+                                          //   `... to the hub. two`
+                                          hub._debugger ( msg.MISSING_FSM, subscriberName )
                                           return
                                       }
                                   const 
@@ -57,8 +65,16 @@ return function _callback ( task, fsmName, state, response ) {
                                   if ( typeof transformFn == 'function' )   data = transformFn (state, response )
                                   else                                      data = response
 
-                                  if ( data.answer && data.answer.hasOwnProperty ( '___internalFlag') )  data.answer = undefined
-                                  
+                                  // `data` can be null/undefined if the response is
+                                  // null and no transformer is set, or if the
+                                  // transformer itself returns null. Guard the
+                                  // `.answer` access so we don't blow up — the
+                                  // placeholder-clear below is a no-op when
+                                  // `data` is falsy, and `fn(data)` will still
+                                  // receive whatever value the user/transformer
+                                  // produced (null included).
+                                  if ( data && data.answer && data.answer.hasOwnProperty ( '___internalFlag') )  data.answer = undefined
+
                                   if ( typeof fn == 'function' )   fn(data)
                                   else                             hub._debugger ( msg.MISSING_FN, cbName )
                                   

package/test/01-basics.js

@@ -529,7 +529,7 @@ it ( 'Callback-function with data argument', done  => {
 
 
   it ( 'Test a Debugger', () => {
-    const 
+    const
         machine = {
                         reactivity : [
                                           [ 'one', 'active', 'two', 'activate'  ]
@@ -543,6 +543,142 @@ it ( 'Callback-function with data argument', done  => {
 
 
 
+
+    // =====================================================================
+    // BUG REGRESSIONS
+    // =====================================================================
+
+    // -----------------------------------------------------------------
+    // BUG A — _callback.js passed `fsmSubscriber` (the whole array of
+    // subscriber names) as the data arg to MISSING_FSM, instead of
+    // `subscriberName` (the specific missing one). The warning message
+    // therefore looked like
+    //   `Warning: Fsm "%s" is not registered to the hub. [ 'two' ]`
+    // instead of the intended
+    //   `Warning: Fsm "%s" is not registered to the hub. two`.
+    // The existing test "Not registered fsm subscriber" only checks the
+    // `str` half of the call, so the wrong data was never noticed.
+    // -----------------------------------------------------------------
+    it ( 'BUG A — MISSING_FSM is logged with the missing name, not the array', done => {
+        const
+              mini = {
+                          init : 'none'
+                        , behavior : [
+                                        [ 'none', 'activate', 'active', 'switchOn' ]
+                                    ]
+                        }
+            , lib  = {
+                          switchOn ({ task }, data) {
+                                  task.done ({ success : true, response : data })
+                              }
+                        }
+            , one = new Fsm ( mini, lib )
+            ;
+        const hub = new FsmHub ({
+                        reactivity : [
+                                          [ 'one', 'active', 'two', 'activate' ]
+                                        ]
+                    });
+        const calls = [];
+        hub._debugger = ( str, data ) => calls.push ({ str, data });
+        hub.addFsm ({ one });   // 'two' is intentionally NOT registered
+
+        one.update ( 'activate', 'try' );
+
+        setTimeout ( () => {
+            const missing = calls.find ( c => c.str === MISSING_FSM )
+            expect ( missing, 'MISSING_FSM was not logged' ).to.exist
+            // The data should be the missing name 'two' (a string),
+            // NOT the whole subscribers array.
+            expect ( missing.data ).to.equal ( 'two' )
+            done ()
+        }, 50 )
+    }) // it BUG A
+
+    // -----------------------------------------------------------------
+    // BUG B — _callback.js crashed with
+    //   `TypeError: Cannot read properties of null (reading 'answer')`
+    // when a callback rule (length 3 in `reactivity`) was triggered
+    // and the FSM's response was `null` (and no transformer was
+    // configured, or the transformer itself returned `null`).
+    //
+    // The existing test "Callback-function with data argument" always
+    // passes a non-null `response`, so this path was never exercised.
+    // -----------------------------------------------------------------
+    it ( 'BUG B — callback rule with null response does not crash', done => {
+        const
+              mini = {
+                          init : 'none'
+                        , behavior : [
+                                        [ 'none', 'activate', 'active', 'switchOn' ]
+                                    ]
+                        }
+            // Transition returns response: null. No transformer.
+            , lib  = {
+                          switchOn ({ task }) {
+                                  task.done ({ success : true, response : null })
+                              }
+                        }
+            , one = new Fsm ( mini, lib )
+            ;
+        const hub = new FsmHub ({
+                        reactivity : [
+                                          // length-3 rule = callback, no fsm subscriber
+                                          [ 'one', 'active', 'showme' ]
+                                        ]
+                    });
+        function showme ( data ) {
+                            // The crash happened BEFORE this was called.
+                            // We just want to assert: the callback fires
+                            // and `data` is what the response was (null).
+                            expect ( data ).to.equal ( null )
+                            done ()
+                        } // showme func.
+        hub.addFsm    ({ one });
+        hub.addFunctions ({ showme });
+
+        one.update ( 'activate' );
+    }) // it BUG B — null response
+
+    it ( 'BUG B — callback rule with a transformer that returns null does not crash', done => {
+        const
+              mini = {
+                          init : 'none'
+                        , behavior : [
+                                        [ 'none', 'activate', 'active', 'switchOn' ]
+                                    ]
+                        }
+            , lib  = {
+                          switchOn ({ task }, data) {
+                                  task.done ({ success : true, response : data })
+                              }
+                        }
+            , one = new Fsm ( mini, lib )
+            ;
+        const hub = new FsmHub ({
+                        reactivity : [
+                                          [ 'one', 'active', 'showme' ]
+                                        ]
+                        , transformers : {
+                                            'one/showme' : 'nullTransformer'
+                                        }
+                    }, {
+                        // A transformer that returns null. This used to
+                        // crash in _callback.js's `data.answer` check.
+                        nullTransformer () { return null }
+                    });
+        function showme ( data ) {
+                            expect ( data ).to.equal ( null )
+                            done ()
+                        } // showme func.
+        hub.addFsm    ({ one });
+        hub.addFunctions ({ showme });
+
+        one.update ( 'activate', 'try' );
+    }) // it BUG B — null transformer
+
+
+
   
 }) // describe