fix: ensure gobalContext is globally shared

telefunc/node/server/globalContext.ts

@@ -1,9 +1,17 @@
-export { globalContext }
+export { getViteDevServer }
+export { setViteDevServer }
 
 import type { ViteDevServer } from 'vite'
+import { getGlobalObject } from '../utils'
 
-const globalContext: GlobalContext = {}
+const globalObject = getGlobalObject<{ viteDevServer: null | ViteDevServer }>('globalContext.ts', {
+  viteDevServer: null
+})
 
-type GlobalContext = {
-  viteDevServer?: ViteDevServer
+function setViteDevServer(viteDevServer: ViteDevServer): void {
+  globalObject.viteDevServer = viteDevServer
+}
+
+function getViteDevServer(): null | ViteDevServer {
+  return globalObject.viteDevServer
 }

telefunc/node/server/runTelefunc.ts

@@ -12,7 +12,6 @@ import { handleError } from './runTelefunc/handleError'
 import { callBugListeners } from './runTelefunc/onBug'
 import { applyShield } from './runTelefunc/applyShield'
 import { findTelefunction } from './runTelefunc/findTelefunction'
-import { globalContext } from './globalContext'
 import { resolveServerConfig } from './serverConfig'
 
 /** The HTTP Response of a telefunction remote call HTTP Request */
@@ -55,7 +54,7 @@ async function runTelefunc(runContext: Parameters<typeof runTelefunc_>[0]) {
     return await runTelefunc_(runContext)
   } catch (err: unknown) {
     callBugListeners(err)
-    handleError(err, globalContext.viteDevServer || null)
+    handleError(err)
     return serverError
   }
 }
@@ -76,8 +75,7 @@ async function runTelefunc_(httpRequest: {
         telefuncUrl: serverConfig.telefuncUrl
       },
       appRootDir: serverConfig.root,
-      telefuncFilesManuallyProvidedByUser: serverConfig.telefuncFiles,
-      viteDevServer: globalContext.viteDevServer ?? null
+      telefuncFilesManuallyProvidedByUser: serverConfig.telefuncFiles
     })
   }
 

telefunc/node/server/runTelefunc/handleError.ts

@@ -2,11 +2,13 @@ export { handleError }
 
 import type { ViteDevServer } from 'vite'
 import { hasProp } from '../../utils'
+import { getViteDevServer } from '../globalContext'
 
-function handleError(err: unknown, viteDevServer: ViteDevServer | null) {
+function handleError(err: unknown) {
   // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
   const errStr = (hasProp(err, 'stack') && String(err.stack)) || String(err)
 
+  const viteDevServer = getViteDevServer()
   if (viteAlreadyLoggedError(err, viteDevServer)) {
     return
   }

telefunc/node/server/runTelefunc/loadTelefuncFiles.ts

@@ -1,6 +1,5 @@
 export { loadTelefuncFiles }
 
-import type { ViteDevServer } from 'vite'
 import type { TelefuncFiles } from '../types'
 import { assertUsage, assert, hasProp } from '../../utils'
 import { loadTelefuncFilesWithVite } from '../../vite/loadTelefuncFilesWithVite'
@@ -9,7 +8,6 @@ import { loadTelefuncFilesFromConfig } from './loadTelefuncFilesFromConfig'
 
 async function loadTelefuncFiles(runContext: {
   appRootDir: string | null
-  viteDevServer: ViteDevServer | null
   telefuncFilesManuallyProvidedByUser: string[] | null
   telefuncFilePath: string
 }): Promise<{ telefuncFilesLoaded: TelefuncFiles; telefuncFilesAll: string[] }> {
@@ -26,7 +24,7 @@ async function loadTelefuncFiles(runContext: {
 
   // Handles:
   // - Next.js
-  // - Nuxt
+  // - Nuxt 2
   // - Vite with `importBuild.js`
   {
     const telefuncFilesLoaded = loadTelefuncFilesWithRegistration()

telefunc/node/vite/loadTelefuncFilesWithVite.ts

@@ -3,18 +3,15 @@ export { loadTelefuncFilesWithVite }
 import { loadBuild } from '@brillout/vite-plugin-import-build/loadBuild'
 import { assert, assertWarning, getNodeEnv, hasProp, isObject, isProduction, isTelefuncFilePath } from '../utils'
 import { telefuncFilesGlobFilePath } from './importGlob/telefuncFilesGlobPath'
-import type { ViteDevServer } from 'vite'
 import { loadTelefuncFilesWithImportBuild } from './plugins/importBuild/loadBuild'
+import { getViteDevServer } from '../server/globalContext'
 
-async function loadTelefuncFilesWithVite(runContext: {
-  telefuncFilePath: string
-  viteDevServer: ViteDevServer | null
-}): Promise<null | {
+async function loadTelefuncFilesWithVite(runContext: { telefuncFilePath: string }): Promise<null | {
   telefuncFilesLoaded: Record<string, Record<string, unknown>>
   telefuncFilesAll: string[]
   viteProvider: 'viteDevServer' | 'importBuild.cjs'
 }> {
-  const ret = await loadGlobImporter(runContext)
+  const ret = await loadGlobImporter()
   if (!ret) {
     return null
   }
@@ -27,14 +24,15 @@ async function loadTelefuncFilesWithVite(runContext: {
   return { telefuncFilesLoaded, viteProvider, telefuncFilesAll }
 }
 
-async function loadGlobImporter(runContext: { viteDevServer: ViteDevServer | null }) {
-  if (runContext.viteDevServer) {
+async function loadGlobImporter() {
+  const viteDevServer = getViteDevServer()
+  if (viteDevServer) {
     const devPath = telefuncFilesGlobFilePath
     let moduleExports: unknown
     try {
-      moduleExports = await runContext.viteDevServer.ssrLoadModule(devPath)
+      moduleExports = await viteDevServer.ssrLoadModule(devPath)
     } catch (err: unknown) {
-      runContext.viteDevServer.ssrFixStacktrace(err as Error)
+      viteDevServer.ssrFixStacktrace(err as Error)
       throw err
     }
     return { moduleExports, viteProvider: 'viteDevServer' as const }

telefunc/node/vite/plugins/retrieveDevServer.ts

@@ -1,13 +1,13 @@
 export { retrieveDevServer }
 
 import type { Plugin } from 'vite'
-import { globalContext } from '../../server/globalContext'
+import { setViteDevServer } from '../../server/globalContext'
 
 function retrieveDevServer(): Plugin {
   return {
     name: 'telefunc:retrieveDevServer',
     configureServer(viteDevServer) {
-      globalContext.viteDevServer = viteDevServer
+      setViteDevServer(viteDevServer)
     }
   } as Plugin
 }