one 1.1.381 → 1.1.382

package/src/server/getServerManifest.ts

@@ -21,12 +21,14 @@ export type OneRouterServerManifestV1Route<TRegex = string> = {
   namedRegex: TRegex
   generated?: boolean
   layouts?: RouteNode[]
+  middlewares?: RouteNode[]
   type: One.RouteType
   isNotFound?: boolean
 }
 
 export type OneRouterServerManifestV1<TRegex = string> = {
   apiRoutes: OneRouterServerManifestV1Route<TRegex>[]
+  middlewareRoutes: OneRouterServerManifestV1Route<TRegex>[]
   pageRoutes: OneRouterServerManifestV1Route<TRegex>[]
 }
 
@@ -96,19 +98,32 @@ export function getServerManifest(route: RouteNode): OneRouterServerManifestV1 {
   }
 
   const apiRoutes: OneRouterServerManifestV1Route[] = []
+  const middlewareRoutes: OneRouterServerManifestV1Route[] = []
   const pageRoutes: OneRouterServerManifestV1Route[] = []
 
+  const addedMiddlewares: Record<string, boolean> = {}
+
   for (const [path, node] of flat) {
     if (node.type === 'api') {
       apiRoutes.push(getGeneratedNamedRouteRegex(path, node))
       continue
     }
 
+    if (node.middlewares?.length) {
+      for (const middleware of node.middlewares) {
+        if (!addedMiddlewares[middleware.contextKey]) {
+          addedMiddlewares[middleware.contextKey] = true
+          middlewareRoutes.push(getGeneratedNamedRouteRegex(path, middleware))
+        }
+      }
+    }
+
     pageRoutes.push(getGeneratedNamedRouteRegex(path, node))
   }
 
   return {
     apiRoutes,
+    middlewareRoutes,
     pageRoutes,
   }
 }
@@ -136,6 +151,7 @@ function getNamedRouteRegex(
     namedRegex: result.namedRegex,
     routeKeys: result.routeKeys,
     layouts: node.layouts,
+    middlewares: node.middlewares,
   }
 }
 

package/src/server/oneServe.ts

@@ -1,24 +1,29 @@
-import type { Hono } from 'hono'
-import { join } from 'node:path'
-import type { VXRNOptions } from 'vxrn'
+import type { Hono, MiddlewareHandler } from 'hono'
+import type { BlankEnv } from 'hono/types'
+import { extname, join } from 'node:path'
 import { getServerEntry } from 'vxrn/serve'
+import { getPathFromLoaderPath } from '../cleanUrl'
+import { LOADER_JS_POSTFIX_UNCACHED } from '../constants'
+import { compileManifest, getURLfromRequestURL, type RequestHandlers } from '../createHandleRequest'
 import type { RenderAppProps } from '../types'
+import { toAbsolute } from '../utils/toAbsolute'
 import type { One } from '../vite/types'
+import type { RouteInfoCompiled } from './createRoutesManifest'
+import { default as FSExtra } from 'fs-extra'
 
 export async function oneServe(
   oneOptions: One.PluginOptions,
-  vxrnOptions: VXRNOptions,
   buildInfo: One.BuildInfo,
   app: Hono,
   serveStatic = true
 ) {
-  const { createHandleRequest } = await import('../createHandleRequest')
+  const { resolveAPIRoute, resolveLoaderRoute, resolvePageRoute } = await import(
+    '../createHandleRequest'
+  )
   const { isResponse } = await import('../utils/isResponse')
   const { isStatusRedirect } = await import('../utils/isStatus')
-  const { resolveAPIRequest } = await import('../vite/resolveAPIRequest')
 
   const isAPIRequest = new WeakMap<any, boolean>()
-  const root = vxrnOptions.root || '.'
 
   // add redirects
   const redirects = oneOptions.web?.redirects
@@ -38,25 +43,11 @@ export async function oneServe(
     throw new Error(`No build info found, have you run build?`)
   }
 
-  const { routeMap, builtRoutes } = buildInfo as One.BuildInfo
-
-  const routeToBuildInfo: Record<string, One.RouteBuildInfo> = {}
-  for (const route of builtRoutes) {
-    routeToBuildInfo[route.cleanPath] = route
-
-    // temp - make it back into brackets style
-    const bracketRoutePath = route.cleanPath
-      .split('/')
-      .map((part) => {
-        return part[0] === ':' ? `[${part.slice(1)}]` : part
-      })
-      .join('/')
-    routeToBuildInfo[bracketRoutePath] = route
-  }
+  const { routeToBuildInfo, routeMap } = buildInfo as One.BuildInfo
 
   const serverOptions = {
     ...oneOptions,
-    root,
+    root: '.',
   }
 
   const entryServer = getServerEntry(serverOptions)
@@ -65,152 +56,155 @@ export async function oneServe(
   const render = entry.default.render as (props: RenderAppProps) => any
   const apiCJS = oneOptions.build?.api?.outputFormat === 'cjs'
 
-  const handleRequest = createHandleRequest(
-    {},
-    {
-      async handleAPI({ route, request, loaderProps }) {
-        const apiFile = join(
-          process.cwd(),
-          'dist',
-          'api',
-          route.page.replace('[', '_').replace(']', '_') + (apiCJS ? '.cjs' : '.js')
-        )
+  const requestHandlers: RequestHandlers = {
+    async handleAPI({ route }) {
+      const apiFile = join(
+        process.cwd(),
+        'dist',
+        'api',
+        route.page.replace('[', '_').replace(']', '_') + (apiCJS ? '.cjs' : '.js')
+      )
+      return await import(apiFile)
+    },
+
+    async loadMiddleware(route) {
+      return await import(toAbsolute(route.contextKey))
+    },
+
+    async handlePage({ route, url, loaderProps }) {
+      if (route.type === 'ssr') {
+        const buildInfo = routeToBuildInfo[route.page]
+
+        if (!buildInfo) {
+          throw new Error(
+            `No buildinfo found for ${url}, route: ${route.page}, in keys: ${Object.keys(routeToBuildInfo)}`
+          )
+        }
 
-        isAPIRequest.set(request, true)
+        try {
+          const exported = await import(toAbsolute(buildInfo.serverJsPath))
+          const loaderData = await exported.loader?.(loaderProps)
+          const preloads = buildInfo.preloads
 
-        return resolveAPIRequest(
-          async () => {
-            try {
-              return await import(apiFile)
-            } catch (err) {
-              console.error(`\n [one] Error importing API route at ${apiFile}:
+          const headers = new Headers()
+          headers.set('content-type', 'text/html')
 
-  ${err}
+          const rendered = await render({
+            loaderData,
+            loaderProps,
+            path: loaderProps?.path || '/',
+            preloads,
+          })
 
-  If this is an import error, you can likely fix this by adding this dependency to
-  the "optimizeDeps.include" array in your vite.config.ts.
+          return new Response(rendered, {
+            headers,
+            status: route.isNotFound ? 404 : 200,
+          })
+        } catch (err) {
+          console.error(`[one] Error rendering SSR route ${route.page}
 
-  🐞 For a better error message run "node" and enter:
+${err?.['stack'] ?? err}
 
-  import('${apiFile}')\n\n`)
-              return {}
-            }
-          },
-          request,
-          loaderProps?.params || {}
-        )
-      },
-
-      async handleSSR({ route, url, loaderProps }) {
-        if (route.type === 'ssr') {
-          const buildInfo = routeToBuildInfo[route.page]
-          if (!buildInfo) {
-            throw new Error(
-              `No buildinfo found for ${url}, route: ${route.page}, in keys: ${Object.keys(routeToBuildInfo)}`
-            )
-          }
-
-          try {
-            const exported = await import(buildInfo.serverJsPath)
-            const loaderData = await exported.loader?.(loaderProps)
-            const preloads = buildInfo.preloads
-
-            const headers = new Headers()
-            headers.set('content-type', 'text/html')
-
-            return new Response(
-              await render({
-                loaderData,
-                loaderProps,
-                path: loaderProps?.path || '/',
-                preloads,
-              }),
-              {
-                headers,
-              }
-            )
-          } catch (err) {
-            console.error(`[one] Error rendering SSR route ${route.page}
-
-  ${err?.['stack'] ?? err}
-
-  url: ${url}`)
-          }
+url: ${url}`)
         }
-      },
-    }
-  )
-
-  // preload reading in all the files, for prod performance:
-  const htmlFiles: Record<string, string> = {}
-
-  if (serveStatic) {
-    const { readFile } = await import('node:fs/promises')
-
-    for (const key in routeMap) {
-      const info = routeToBuildInfo[key]
+      } else {
+        const htmlPath = routeMap[route['honoPath']]
+        if (htmlPath) {
+          const html = await FSExtra.readFile(
+            join('dist/client', routeMap[route['honoPath']]),
+            'utf-8'
+          )
+          const headers = new Headers()
+          headers.set('content-type', 'text/html')
+          return new Response(html, { headers, status: route.isNotFound ? 404 : 200 })
+        }
+      }
+    },
+  }
 
-      if (info?.type === 'ssr') {
-        // we handle this on each request
-        continue
+  function createHonoHandler(route: RouteInfoCompiled): MiddlewareHandler<BlankEnv, never, {}> {
+    return async (context, next) => {
+      // assets we ignore
+      if (extname(context.req.path)) {
+        return await next()
       }
 
-      htmlFiles[key] = await readFile(join('dist/client', routeMap[key]), 'utf-8')
-    }
-  }
+      try {
+        const request = context.req.raw
+        const url = getURLfromRequestURL(request)
 
-  app.use(async (context, next) => {
-    // serve our generated html files
-    const html = htmlFiles[context.req.path]
-    if (html) {
-      return context.html(html)
-    }
+        const response = await (() => {
+          // where to put this best? can likely be after some of the switch?
+          if (url.pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
+            const originalUrl = getPathFromLoaderPath(url.pathname)
+            const finalUrl = new URL(originalUrl, url.origin)
+            return resolveLoaderRoute(requestHandlers, request, finalUrl, route)
+          }
 
-    try {
-      const request = context.req.raw
-      const response = await handleRequest.handler(request)
-
-      if (response) {
-        if (isResponse(response)) {
-          if (isStatusRedirect(response.status)) {
-            const location = `${response.headers.get('location') || ''}`
-            response.headers.forEach((value, key) => {
-              context.header(key, value)
-            })
-            return context.redirect(location, response.status)
+          switch (route.type) {
+            case 'api': {
+              return resolveAPIRoute(requestHandlers, request, url, route)
+            }
+            case 'ssg':
+            case 'spa':
+            case 'ssr': {
+              return resolvePageRoute(requestHandlers, request, url, route)
+            }
           }
+        })()
+
+        if (response) {
+          if (isResponse(response)) {
+            // const cloned = response.clone()
+
+            if (isStatusRedirect(response.status)) {
+              const location = `${response.headers.get('location') || ''}`
+              response.headers.forEach((value, key) => {
+                context.header(key, value)
+              })
+              return context.redirect(location, response.status)
+            }
 
-          if (isAPIRequest.get(request)) {
-            try {
-              // don't cache api requests by default
-              response.headers.set('Cache-Control', 'no-store')
-            } catch (err) {
-              console.info(
-                `Error udpating cache header on api route "${
-                  context.req.path
-                }" to no-store, it is ${response.headers.get('cache-control')}, continue`,
-                err
-              )
+            if (isAPIRequest.get(request)) {
+              try {
+                // don't cache api requests by default
+                response.headers.set('Cache-Control', 'no-store')
+                return response
+              } catch (err) {
+                console.info(
+                  `Error udpating cache header on api route "${
+                    context.req.path
+                  }" to no-store, it is ${response.headers.get('cache-control')}, continue`,
+                  err
+                )
+              }
             }
+
+            return response as Response
           }
 
-          return response as Response
+          return await next()
         }
-
-        return context.json(
-          response,
-          200,
-          isAPIRequest.get(request)
-            ? {
-                'Cache-Control': 'no-store',
-              }
-            : undefined
-        )
+      } catch (err) {
+        console.error(` [one] Error handling request: ${(err as any)['stack']}`)
       }
-    } catch (err) {
-      console.error(` [one] Error handling request: ${(err as any)['stack']}`)
+
+      return await next()
     }
+  }
 
-    await next()
-  })
+  const compiledManifest = compileManifest(buildInfo.manifest)
+
+  for (const route of compiledManifest.apiRoutes) {
+    app.get(route.honoPath, createHonoHandler(route))
+    app.put(route.honoPath, createHonoHandler(route))
+    app.post(route.honoPath, createHonoHandler(route))
+    app.delete(route.honoPath, createHonoHandler(route))
+    app.patch(route.honoPath, createHonoHandler(route))
+  }
+
+  for (const route of compiledManifest.pageRoutes) {
+    console.log('add', route.honoPath)
+    app.get(route.honoPath, createHonoHandler(route))
+  }
 }

package/src/types.ts

@@ -12,10 +12,6 @@ export type Options = {
   preserveApiRoutes?: boolean
   ignoreRequireErrors?: boolean
   ignoreEntryPoints?: boolean
-  /* Used to simplify testing for toEqual() comparison */
-  internal_stripLoadRoute?: boolean
-  /* Used to simplify by skipping the generated routes */
-  skipGenerated?: boolean
   importMode?: string
   platformRoutes?: boolean
   platform?: string

package/src/utils/getHonoPath.ts

@@ -0,0 +1,17 @@
+export function getHonoPath(page: string) {
+  return (
+    page
+      // /(param) => (empty)
+      .replaceAll(/\/\(([^\)]+)\)/gi, '')
+      // [...params] => *
+      .replace(/\[...([^\]]+)\]/gi, '*')
+      // [param] => :param
+      .replaceAll(/\[([^\]]+)\]/gi, ':$1')
+      // +not-found => *
+      .replace('+not-found', '*')
+      // /index => /
+      .replace(/\/index$/, '/')
+      // remove trailing / for non / paths
+      .replace(/.+\/$/, '')
+  )
+}

package/src/utils/toAbsolute.ts

@@ -0,0 +1,3 @@
+import { resolve } from 'node:path'
+
+export const toAbsolute = (p: string) => resolve(process.cwd(), p)

package/src/vite/one.ts

@@ -2,6 +2,7 @@ import { resolvePath } from '@vxrn/resolve'
 import events from 'node:events'
 import path, { dirname, resolve } from 'node:path'
 import type { Plugin, PluginOption, UserConfig } from 'vite'
+import { barrel } from 'vite-plugin-barrel'
 import tsconfigPaths from 'vite-tsconfig-paths'
 import {
   autoPreBundleDepsForSsrPlugin,
@@ -21,10 +22,9 @@ import { fixDependenciesPlugin } from './plugins/fixDependenciesPlugin'
 import { generateFileSystemRouteTypesPlugin } from './plugins/generateFileSystemRouteTypesPlugin'
 import { createReactCompilerPlugin } from './plugins/reactCompilerPlugin'
 import { SSRCSSPlugin } from './plugins/SSRCSSPlugin'
-import { createVirtualEntry } from './plugins/virtualEntryPlugin'
 import { virtualEntryId } from './plugins/virtualEntryConstants'
+import { createVirtualEntry } from './plugins/virtualEntryPlugin'
 import type { One } from './types'
-import { barrel } from 'vite-plugin-barrel'
 
 /**
  * This needs a big refactor!
@@ -38,16 +38,24 @@ events.setMaxListeners(1_000)
 // temporary for tamagui plugin compat
 globalThis.__vxrnEnableNativeEnv = true
 
+// temporary until we fix double-load issue, which means we'd have to somehow
+// not control the port/host from our config, but still pass it into ENV
+// until then we want to avoid double loading everything on first start
+
 export function one(options: One.PluginOptions = {}): PluginOption {
-  setOneOptions(options)
+  if (!globalThis.__oneOptions) {
+    // first load we are just loading it ourselves to get the user options
+    // so we can just set here and return nothing
+    setOneOptions(options)
+    globalThis['__vxrnPluginConfig__'] = options
+    return []
+  }
 
   // ensure tsconfig
   if (options.config?.ensureTSConfig !== false) {
     void ensureTSConfig()
   }
 
-  globalThis['__vxrnPluginConfig__'] = options
-
   // build is superset for now
   const { optimizeDeps } = getOptimizeDeps('build')
   const optimizeIds = optimizeDeps.include

package/src/vite/plugins/fileSystemRouterPlugin.tsx

@@ -10,7 +10,6 @@ import { isStatusRedirect } from '../../utils/isStatus'
 import { promiseWithResolvers } from '../../utils/promiseWithResolvers'
 import { LoaderDataCache } from '../../vite/constants'
 import { replaceLoader } from '../../vite/replaceLoader'
-import { resolveAPIRequest } from '../../vite/resolveAPIRequest'
 import type { One } from '../../vite/types'
 import { virtalEntryIdClient, virtualEntryId } from './virtualEntryConstants'
 
@@ -28,8 +27,8 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
   let renderPromise: Promise<void> | null = null
 
   function createRequestHandler() {
-    return createHandleRequest(options, {
-      async handleSSR({ route, url, loaderProps }) {
+    return createHandleRequest({
+      async handlePage({ route, url, loaderProps }) {
         console.info(` ⓵  [${route.type}] ${url} resolved to ${route.file}`)
 
         if (route.type === 'spa') {
@@ -142,12 +141,7 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
           throw new Error(`No transformed js returned`)
         }
 
-        // if (!transformedJS.includes('loader')) {
-        //   return `console.log("hi")`
-        // }
-
         const exported = await runner.import(routeFile)
-
         const loaderData = await exported.loader?.(loaderProps)
 
         if (loaderData) {
@@ -177,13 +171,12 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
         return transformedJS
       },
 
-      async handleAPI({ request, route, url, loaderProps }) {
-        const result = await resolveAPIRequest(
-          () => runner.import(join('app', route.file)),
-          request,
-          loaderProps?.params || {}
-        )
-        return result
+      async handleAPI({ route }) {
+        return await runner.import(join('app', route.file))
+      },
+
+      async loadMiddleware(route) {
+        return await runner.import(join('app', route.contextKey))
       },
     })
   }

package/src/vite/resolveResponse.ts

@@ -0,0 +1,93 @@
+import { isResponse } from '../utils/isResponse'
+import { asyncHeadersCache, mergeHeaders, requestAsyncLocalStore } from './server'
+
+export function resolveResponse(getResponse: () => Promise<Response>) {
+  return new Promise<Response>((res, rej) => {
+    const id = { _id: Math.random() }
+    requestAsyncLocalStore.run(id, async () => {
+      try {
+        const response = await getResponse()
+        const modifiedResponse = await getResponseWithAddedHeaders(response, id)
+        res(modifiedResponse)
+      } catch (err) {
+        // allow throwing a response
+        if (isResponse(err)) {
+          res(err)
+        } else {
+          rej(err) // reject the promise on any other error
+        }
+      }
+    })
+  })
+}
+
+export function resolveAPIEndpoint(
+  // this is the result of importing the file:
+  runEndpoint: () => Promise<any>,
+  request: Request,
+  params: Record<string, string>
+) {
+  return resolveResponse(async () => {
+    const imported = await runEndpoint()
+    const requestType = request.method || 'GET'
+    const handler = imported[requestType] || imported.default
+    if (!handler) {
+      console.warn(`No handler found for request ${requestType}`)
+      return
+    }
+    return await handler(request, { params })
+  })
+}
+
+async function getResponseWithAddedHeaders(response: any, id: Object) {
+  const asyncHeaders = asyncHeadersCache.get(id)
+
+  if (asyncHeaders) {
+    try {
+      if (response instanceof Response) {
+        mergeHeaders(response.headers, asyncHeaders)
+      } else {
+        if (response && typeof response === 'object') {
+          response = Response.json(response, { headers: asyncHeaders })
+        } else {
+          response = new Response(response as any, { headers: asyncHeaders })
+        }
+      }
+    } catch (err) {
+      if (`${err}`.includes('immutable')) {
+        // we have to create a new response
+        const body = response.body ? await streamToString(response.body) : ''
+        response = new Response(body, {
+          headers: response.headers,
+          status: response.status,
+          statusText: response.statusText,
+        })
+        mergeHeaders(response.headers, asyncHeaders)
+      } else {
+        console.error(` [one] error adding headers: ${err}`)
+      }
+    }
+  }
+
+  return response
+}
+
+async function streamToString(stream: ReadableStream) {
+  const reader = stream.getReader()
+  const decoder = new TextDecoder()
+  let result = ''
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      result += decoder.decode(value, { stream: true })
+    }
+  } catch (error) {
+    console.error('Error reading the stream:', error)
+  } finally {
+    reader.releaseLock()
+  }
+
+  return result
+}

package/src/vite/{headers.native.ts → server.native.ts}

@@ -4,6 +4,6 @@ export const asyncHeadersCache = new WeakMap<any, Headers>()
 
 // TODO move this to `RequestContext.setHeaders()`
 
-export async function setCurrentRequestHeaders(cb: (headers: Headers) => void) {}
+export async function setResponseHeaders(cb: (headers: Headers) => void) {}
 
 export function mergeHeaders(onto: Headers, from: Headers) {}

package/src/vite/{headers.ts → server.ts}

@@ -16,7 +16,7 @@ globalThis['__vxrnasyncHeadersCache'] ||= asyncHeadersCache
 
 // TODO move this to `RequestContext.setHeaders()`
 
-export async function setCurrentRequestHeaders(cb: (headers: Headers) => void) {
+export async function setResponseHeaders(cb: (headers: Headers) => void) {
   const id = requestAsyncLocalStore.getStore()
 
   if (!id) {