inertia-sails 1.3.0 → 1.3.2

package/index.js

@@ -110,6 +110,38 @@ module.exports = function defineInertiaHook(sails) {
         }
       }
     },
+
+    /**
+     * Configure phase — runs after all hooks' defaults are merged but BEFORE
+     * any hook's initialize(). This is the right place to inject HTTP middleware
+     * because the HTTP hook hasn't read the middleware order yet.
+     */
+    configure: function () {
+      // Inject AsyncLocalStorage context middleware into the HTTP stack
+      // BEFORE the router. This guarantees context is available in ALL
+      // routes.before handlers from all hooks, regardless of hook load order.
+      //
+      // Lifecycle:
+      //   cookieParser → session → bodyParser → ... → inertiaContext → router
+      //
+      // By the time any routes.before handler calls sails.inertia.share(),
+      // the request is already wrapped in AsyncLocalStorage context.
+      if (sails.config.http && sails.config.http.middleware) {
+        const mw = sails.config.http.middleware
+        if (mw.order && mw.order.indexOf('inertiaContext') === -1) {
+          const routerIdx = mw.order.indexOf('router')
+          if (routerIdx !== -1) {
+            mw.order.splice(routerIdx, 0, 'inertiaContext')
+          }
+        }
+        if (!mw.inertiaContext) {
+          mw.inertiaContext = function inertiaContext(req, res, next) {
+            requestContext.run(req, res, next)
+          }
+        }
+      }
+    },
+
     initialize: async function () {
       hook = this
       sails.inertia = hook
@@ -127,19 +159,36 @@ module.exports = function defineInertiaHook(sails) {
     },
 
     /**
-     * Hook routes - sets up AsyncLocalStorage context early so other hooks
-     * can use sails.inertia.share() with proper request-scoped context.
+     * Hook routes — fallback context setup for socket requests.
+     * HTTP requests already have context from the inertiaContext middleware.
+     * Socket requests bypass Express middleware, so they need this.
      */
     routes: {
       before: {
         'GET /*': {
           skipAssets: true,
-          fn: (req, res, next) => requestContext.run(req, res, next)
+          fn: (req, res, next) => {
+            // Skip if context already set up by HTTP middleware
+            if (requestContext.getContext()) return next()
+            requestContext.run(req, res, next)
+          }
+        },
+        'POST /*': (req, res, next) => {
+          if (requestContext.getContext()) return next()
+          requestContext.run(req, res, next)
         },
-        'POST /*': (req, res, next) => requestContext.run(req, res, next),
-        'PUT /*': (req, res, next) => requestContext.run(req, res, next),
-        'PATCH /*': (req, res, next) => requestContext.run(req, res, next),
-        'DELETE /*': (req, res, next) => requestContext.run(req, res, next)
+        'PUT /*': (req, res, next) => {
+          if (requestContext.getContext()) return next()
+          requestContext.run(req, res, next)
+        },
+        'PATCH /*': (req, res, next) => {
+          if (requestContext.getContext()) return next()
+          requestContext.run(req, res, next)
+        },
+        'DELETE /*': (req, res, next) => {
+          if (requestContext.getContext()) return next()
+          requestContext.run(req, res, next)
+        }
       }
     },
 
@@ -152,14 +201,17 @@ module.exports = function defineInertiaHook(sails) {
      * @returns {*} - The value that was shared
      */
     share(key, value = null) {
-      // If we're in a request context, share for this request only
       const context = requestContext.getContext()
       if (context) {
         requestContext.setSharedProp(key, value)
         return value
       }
-      // Fallback to global share if called outside request (e.g., in hooks)
-      sails.inertia.globalSharedProps[key] = value
+      // Never fall back to global — that causes data to leak across requests.
+      // Use shareGlobally() for truly global data like app name.
+      sails.log.warn(
+        `sails.inertia.share('${key}') called outside request context. ` +
+          'Value was not stored. Use shareGlobally() for global data.'
+      )
       return value
     },
 
@@ -190,27 +242,24 @@ module.exports = function defineInertiaHook(sails) {
 
     /**
      * Flush shared properties for the current request.
-     * Since context is set up early in routes.before, this always works
-     * in hooks and middleware.
+     * Always flushes from both request-scoped AND global storage to prevent
+     * stale data from leaking across requests.
      * @param {string|null} key - The key of the property to flush, or null to flush all
-     * @param {boolean} [global=false] - Whether to also flush global props (rarely needed)
      */
-    flushShared(key, global = false) {
+    flushShared(key) {
       const context = requestContext.getContext()
       if (key) {
         if (context) {
           delete context.sharedProps[key]
         }
-        if (global) {
-          delete sails.inertia.globalSharedProps[key]
-        }
+        // Always clean global too — prevents stale data from a previous
+        // request (or a share() that fell through before context was ready)
+        delete sails.inertia.globalSharedProps[key]
       } else {
         if (context) {
           context.sharedProps = {}
         }
-        if (global) {
-          sails.inertia.globalSharedProps = {}
-        }
+        sails.inertia.globalSharedProps = {}
       }
     },
 
@@ -227,8 +276,10 @@ module.exports = function defineInertiaHook(sails) {
         requestContext.setSharedLocal(key, value)
         return value
       }
-      // Fallback to global if called outside request
-      sails.inertia.globalSharedLocals[key] = value
+      sails.log.warn(
+        `sails.inertia.local('${key}') called outside request context. ` +
+          'Value was not stored. Use localGlobally() for global data.'
+      )
       return value
     },
 

package/lib/helpers/request-context.js

@@ -46,7 +46,7 @@ module.exports = {
       refreshOnceProps: [], // Props to force-refresh for this request
       rootView: null // Request-scoped root view template
     }
-    return requestContext.run(context, callback)
+    return requestContext.run(context, () => callback())
   },
 
   /**

package/lib/render.js

@@ -32,6 +32,15 @@ module.exports = async function render(req, res, data) {
     return res.json(page)
   } else {
     // Implements full page reload
-    return res.view(rootView, { page, ...allLocals })
+    //
+    // We pass locals both as top-level properties AND nested under a `locals`
+    // key. This is necessary because Sails's default EJS renderer creates an
+    // `options.locals` object (for blocks, layout, partial helpers). EJS wraps
+    // templates in `with(data) { ... }`, so inside the template `locals`
+    // resolves to `data.locals` (the nested object) rather than the `locals`
+    // function parameter. By pre-populating `data.locals` with our values,
+    // `<%= locals.title %>` in the EJS template correctly resolves to the
+    // dynamic value instead of undefined.
+    return res.view(rootView, { page, ...allLocals, locals: { ...allLocals } })
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inertia-sails",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "The Sails adapter for Inertia.",
   "main": "index.js",
   "sails": {