nullstack · Mortaro · Jan 31, 2023 · Jan 31, 2023
diff --git a/server/reqres.js b/server/reqres.js
@@ -1,2 +1,20 @@
-const reqres = {}
+class ReqRes {
+
+  request = null
+  response = null
+
+  set(request, response) {
+    this.request = request
+    this.response = response
+  }
+
+  clear() {
+    this.request = null
+    this.response = null
+  }
+
+}
+
+const reqres = new ReqRes()
+
 export default reqres
diff --git a/server/server.js b/server/server.js
@@ -40,6 +40,7 @@ for (const method of ['get', 'post', 'put', 'patch', 'delete', 'all']) {
   server[method] = function (...args) {
     if (typeof args[1] === 'function' && args[1].name === '_invoke') {
       return original(args[0], bodyParser.text({ limit: server.maximumPayloadSize }), async (request, response) => {
+        reqres.set(request, response)
         const params = {}
         for (const key of Object.keys(request.params)) {
           params[key] = extractParamValue(request.params[key])
@@ -53,9 +54,11 @@ for (const method of ['get', 'post', 'put', 'patch', 'delete', 'all']) {
         try {
           const subcontext = generateContext({ request, response, ...params })
           const result = await args[1](subcontext)
+          reqres.clear()
           response.json(result)
         } catch (error) {
           printError(error)
+          reqres.clear()
           response.status(500).json({})
         }
       })
@@ -224,6 +227,7 @@ server.start = function () {
 
   server.all(`/${prefix}/:hash/:methodName.json`, async (request, response) => {
     const payload = request.method === 'GET' ? request.query.payload : request.body
+    reqres.set(request, response)
     const args = deserialize(payload)
     const { hash, methodName } = request.params
     const [invokerHash, boundHash] = hash.split('-')
@@ -241,12 +245,15 @@ server.start = function () {
       try {
         const subcontext = generateContext({ request, response, ...args })
         const result = await method.call(boundKlass, subcontext)
+        reqres.clear()
         response.json({ result })
       } catch (error) {
         printError(error)
+        reqres.clear()
         response.status(500).json({})
       }
     } else {
+      reqres.clear()
       response.status(404).json({})
     }
   })
@@ -255,18 +262,15 @@ server.start = function () {
     if (request.originalUrl.split('?')[0].indexOf('.') > -1) {
       return next()
     }
-    reqres.request = request
-    reqres.response = response
+    reqres.set(request, response)
     const scope = await prerender(request, response)
     if (!response.headersSent) {
       const status = scope.context.page.status
       const html = template(scope)
-      reqres.request = null
-      reqres.response = null
+      reqres.clear()
       response.status(status).send(html)
     } else {
-      reqres.request = null
-      reqres.response = null
+      reqres.clear()
     }
   })
 

diff --git a/tests/client.js b/tests/client.js
@@ -15,6 +15,7 @@ context.start = function () {
 
 context.catch = async function (error) {
   CatchError.logError({ message: error.message })
+  console.error(error)
 }
 
 export default context
diff --git a/tests/server.js b/tests/server.js
@@ -10,6 +10,7 @@ import ContextSettings from './src/ContextSettings'
 import ContextWorker from './src/ContextWorker'
 import ExposedServerFunctions from './src/ExposedServerFunctions'
 import vueable from './src/plugins/vueable'
+import ReqRes from './src/ReqRes'
 
 Nullstack.use(vueable)
 
@@ -41,6 +42,9 @@ context.server.put('/data/put/:param', ExposedServerFunctions.getData)
 context.server.patch('/data/patch/:param', ExposedServerFunctions.getData)
 context.server.delete('/data/delete/:param', ExposedServerFunctions.getData)
 
+context.server.get('/exposed-server-function-url.json', ReqRes.exposedServerFunction)
+context.server.get('/nested-exposed-server-function-url.json', ReqRes.nestedExposedServerFunction)
+
 context.server.get('/custom-api-before-start', (request, response) => {
   response.json({ startValue: context.startValue })
 })
@@ -75,6 +79,7 @@ context.start = async function () {
 
 context.catch = async function (error) {
   CatchError.logError({ message: error.message })
+  console.error(error)
 }
 
 export default context
diff --git a/tests/src/Application.njs b/tests/src/Application.njs
@@ -41,6 +41,7 @@ import PublicServerFunctions from './PublicServerFunctions.njs'
 import PureComponents from './PureComponents'
 import Refs from './Refs'
 import RenderableComponent from './RenderableComponent'
+import ReqRes from './ReqRes'
 import RoutesAndParams from './RoutesAndParams'
 import RouteScroll from './RouteScroll'
 import ServerFunctions from './ServerFunctions'
@@ -139,6 +140,7 @@ class Application extends Nullstack {
         <IsomorphicImport route="/isomorphic-import" />
         <ExposedServerFunctions route="/exposed-server-functions" />
         <CatchError route="/catch-error" />
+        <ReqRes route="/reqres" />
         <ErrorPage route="*" />
       </body>
     )

diff --git a/tests/src/ReqRes.njs b/tests/src/ReqRes.njs
@@ -0,0 +1,82 @@
+import Nullstack from 'nullstack'
+
+class ReqRes extends Nullstack {
+
+  static async innerNestedServerFunctionFromClient(context) {
+    return context.request.originalUrl
+  }
+
+  static async nestedServerFunctionFromClient() {
+    return this.innerNestedServerFunctionFromClient()
+  }
+
+  static async serverFunctionFromClient(context) {
+    return context.request.originalUrl
+  }
+
+  static async innerNestedServerFunction(context) {
+    return context.request.originalUrl
+  }
+
+  static async serverFunction(context) {
+    return context.request.originalUrl
+  }
+
+  static async nestedServerFunction() {
+    return this.innerNestedServerFunction()
+  }
+
+  static async innerNestedExposedServerFunction(context) {
+    return context.request.originalUrl
+  }
+
+  static async nestedExposedServerFunction() {
+    return this.innerNestedExposedServerFunction()
+  }
+
+  static async exposedServerFunction(context) {
+    return context.request.originalUrl
+  }
+
+  async initiate() {
+    this.serverFunctionUrl = await ReqRes.serverFunction()
+    this.nestedServerFunctionUrl = await ReqRes.nestedServerFunction()
+  }
+
+  async fetchServerFunction({ slug }) {
+    const response = await fetch(`/${slug}.json`)
+    return response.json()
+  }
+
+  async hydrate() {
+    this.serverFunctionFromClientUrl = await ReqRes.serverFunctionFromClient()
+    this.nestedServerFunctionFromClientUrl = await ReqRes.nestedServerFunctionFromClient()
+    this.exposedServerFunctionUrl = await this.fetchServerFunction({ slug: 'exposed-server-function-url' })
+    this.nestedExposedServerFunctionUrl = await this.fetchServerFunction({ slug: 'nested-exposed-server-function-url' })
+  }
+
+  render() {
+    return (
+      <div
+        data-server-function={this.serverFunctionUrl === '/reqres'}
+        data-nested-server-function={this.nestedServerFunctionUrl === '/reqres'}
+        data-server-function-from-client={
+          this.serverFunctionFromClientUrl ===
+          '/nullstack/3f8aea65a953b05e7a7a412d1188ac14/serverFunctionFromClient.json'
+        }
+        data-nested-server-function-from-client={
+          this.nestedServerFunctionFromClientUrl ===
+          '/nullstack/3f8aea65a953b05e7a7a412d1188ac14/nestedServerFunctionFromClient.json'
+        }
+        data-exposed-server-function={this.exposedServerFunctionUrl === '/exposed-server-function-url.json'}
+        data-exposed-nested-server-function={
+          this.nestedExposedServerFunctionUrl === '/nested-exposed-server-function-url.json'
+        }
+        data-hydrated={this.hydrated}
+      />
+    )
+  }
+
+}
+
+export default ReqRes
diff --git a/tests/src/ReqRes.test.js b/tests/src/ReqRes.test.js
@@ -0,0 +1,42 @@
+beforeAll(async () => {
+  await page.goto('http://localhost:6969/reqres')
+  await page.waitForSelector('[data-hydrated]')
+})
+
+describe('ReqRes', () => {
+  test('server functions keep the request', async () => {
+    await page.waitForSelector('[data-server-function]')
+    const element = await page.$('[data-server-function]')
+    expect(element).toBeTruthy()
+  })
+
+  test('nested server functions keep the request', async () => {
+    await page.waitForSelector('[data-nested-server-function]')
+    const element = await page.$('[data-nested-server-function]')
+    expect(element).toBeTruthy()
+  })
+
+  test('server functions keep the request when invoked by the client', async () => {
+    await page.waitForSelector('[data-server-function-from-client]')
+    const element = await page.$('[data-server-function-from-client]')
+    expect(element).toBeTruthy()
+  })
+
+  test('nested server functions keep the request when invoked by the client', async () => {
+    await page.waitForSelector('[data-nested-server-function-from-client]')
+    const element = await page.$('[data-nested-server-function-from-client]')
+    expect(element).toBeTruthy()
+  })
+
+  test('exposed server functions keep the request', async () => {
+    await page.waitForSelector('[data-exposed-server-function]')
+    const element = await page.$('[data-exposed-server-function]')
+    expect(element).toBeTruthy()
+  })
+
+  test('nested exposed server functions keep the request', async () => {
+    await page.waitForSelector('[data-exposed-nested-server-function]')
+    const element = await page.$('[data-exposed-nested-server-function]')
+    expect(element).toBeTruthy()
+  })
+})