inertia-sails 1.2.0 → 1.3.1

package/README.md

@@ -75,7 +75,7 @@ Return an Inertia page response:
 return {
   page: 'users/index',       // Component name
   props: { users: [...] },   // Props passed to component
-  viewData: { title: '...' } // Data for root EJS template
+  locals: { title: '...' }   // Locals for root EJS template
 }
 ```
 
@@ -106,12 +106,12 @@ Share data across all requests (app-wide):
 sails.inertia.shareGlobally('appName', 'My App')
 ```
 
-#### `viewData(key, value)`
+#### `local(key, value)`
 
-Share data with the root EJS template:
+Set a local variable for the root EJS template:
 
 ```js
-sails.inertia.viewData('title', 'Dashboard')
+sails.inertia.local('title', 'Dashboard')
 ```
 
 ### Once Props (Cached)

package/index.js

@@ -30,7 +30,7 @@
  * @typedef {Object} InertiaRenderData
  * @property {string} page - The component name to render
  * @property {Object.<string, *>} [props] - Props to pass to the component
- * @property {Object.<string, *>} [viewData] - Additional view data for the root template
+ * @property {Object.<string, *>} [locals] - Additional locals for the root EJS template
  */
 
 /**
@@ -110,13 +110,45 @@ 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
       // Global shared props (for app-wide data like app name, version)
       // These are merged with request-scoped shares
       sails.inertia.globalSharedProps = {}
-      sails.inertia.globalSharedViewData = {}
+      sails.inertia.globalSharedLocals = {}
       // Default history encryption from config
       sails.inertia.defaultEncryptHistory = sails.config.inertia.history.encrypt
       sails.on('router:before', function () {
@@ -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) => 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)
+        'POST /*': (req, res, next) => {
+          if (requestContext.getContext()) return 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,67 +242,66 @@ 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 = {}
       }
     },
 
     /**
-     * Add view data for the current request.
+     * Set a local for the current request's root EJS template.
      * Uses AsyncLocalStorage to ensure data doesn't leak between concurrent requests.
-     * @param {string} key - The key of the view data
-     * @param {*} value - The value of the view data
+     * @param {string} key - The local variable name
+     * @param {*} value - The value
      * @returns {*} - The value that was set
      */
-    viewData(key, value) {
+    local(key, value) {
       const context = requestContext.getContext()
       if (context) {
-        requestContext.setSharedViewData(key, value)
+        requestContext.setSharedLocal(key, value)
         return value
       }
-      // Fallback to global if called outside request
-      sails.inertia.globalSharedViewData[key] = value
+      sails.log.warn(
+        `sails.inertia.local('${key}') called outside request context. ` +
+          'Value was not stored. Use localGlobally() for global data.'
+      )
       return value
     },
 
     /**
-     * Add view data globally across all requests.
-     * @param {string} key - The key of the view data
-     * @param {*} value - The value of the view data
+     * Set a local globally across all requests.
+     * @param {string} key - The local variable name
+     * @param {*} value - The value
      * @returns {*} - The value that was set
      */
-    viewDataGlobally(key, value) {
-      sails.inertia.globalSharedViewData[key] = value
+    localGlobally(key, value) {
+      sails.inertia.globalSharedLocals[key] = value
       return value
     },
 
     /**
-     * Get view data (merges global + request-scoped)
-     * @param {string} key - The key of the view data to get
-     * @returns {*} - The view data
+     * Get locals (merges global + request-scoped)
+     * @param {string} key - The local variable name to get
+     * @returns {*} - The locals
      */
-    getViewData(key) {
-      const globalData = sails.inertia.globalSharedViewData
-      const requestData = requestContext.getSharedViewData()
+    getLocals(key) {
+      const globalData = sails.inertia.globalSharedLocals
+      const requestData = requestContext.getSharedLocals()
       const merged = { ...globalData, ...requestData }
       return key ? merged[key] : merged
     },

package/lib/helpers/request-context.js

@@ -11,7 +11,7 @@
  *   req: Request,
  *   res: Response,
  *   sharedProps: {},      // Request-scoped shared props
- *   sharedViewData: {},   // Request-scoped view data
+ *   sharedLocals: {},     // Request-scoped locals for root EJS template
  *   encryptHistory: null, // Request-scoped history encryption (null = use default)
  *   clearHistory: false,  // Request-scoped clear history flag
  *   refreshOnceProps: [], // Props to force-refresh for this request
@@ -40,13 +40,13 @@ module.exports = {
       req,
       res,
       sharedProps: {},
-      sharedViewData: {},
+      sharedLocals: {},
       encryptHistory: null,
       clearHistory: false,
       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())
   },
 
   /**
@@ -97,23 +97,23 @@ module.exports = {
   },
 
   /**
-   * Get request-scoped shared view data
-   * @returns {Object} - The shared view data for this request
+   * Get request-scoped shared locals
+   * @returns {Object} - The shared locals for this request
    */
-  getSharedViewData() {
+  getSharedLocals() {
     const context = requestContext.getStore()
-    return context?.sharedViewData || {}
+    return context?.sharedLocals || {}
   },
 
   /**
-   * Set request-scoped shared view data
+   * Set a request-scoped shared local
    * @param {string} key - The key
    * @param {*} value - The value
    */
-  setSharedViewData(key, value) {
+  setSharedLocal(key, value) {
     const context = requestContext.getStore()
     if (context) {
-      context.sharedViewData[key] = value
+      context.sharedLocals[key] = value
     }
   },
 

package/lib/render.js

@@ -8,11 +8,11 @@ module.exports = async function render(req, res, data) {
   // Use request-scoped rootView if set, otherwise fall back to config
   const rootView = requestContext.getRootView() || sails.config.inertia.rootView
 
-  // Use request-scoped view data merged with global view data
-  // This prevents view data from leaking between concurrent requests
-  const allViewData = {
-    ...sails.inertia.getViewData(), // Merges global + request-scoped
-    ...data.viewData
+  // Use request-scoped locals merged with global locals
+  // This prevents locals from leaking between concurrent requests
+  const allLocals = {
+    ...sails.inertia.getLocals(), // Merges global + request-scoped
+    ...data.locals
   }
 
   let page = await buildPageObject(req, data.page, data.props)
@@ -32,9 +32,6 @@ module.exports = async function render(req, res, data) {
     return res.json(page)
   } else {
     // Implements full page reload
-    return res.view(rootView, {
-      page,
-      viewData: allViewData
-    })
+    return res.view(rootView, { page, ...allLocals })
   }
 }

package/package.json

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