one 1.1.381 → 1.1.383

package/src/createHandleRequest.ts

@@ -1,11 +1,20 @@
 import { getPathFromLoaderPath } from './cleanUrl'
 import { LOADER_JS_POSTFIX_UNCACHED } from './constants'
-import type { RouteInfo } from './server/createRoutesManifest'
+import type { Middleware, MiddlewareContext } from './createMiddleware'
+import type { RouteNode } from './Route'
+import type { RouteInfo, RouteInfoCompiled } from './server/createRoutesManifest'
 import type { LoaderProps } from './types'
+import { getHonoPath } from './utils/getHonoPath'
 import { isResponse } from './utils/isResponse'
-import { promiseWithResolvers } from './utils/promiseWithResolvers'
 import { getManifest } from './vite/getManifest'
-import type { One } from './vite/types'
+import { resolveAPIEndpoint, resolveResponse } from './vite/resolveResponse'
+
+export type RequestHandlers = {
+  handlePage?: (props: RequestHandlerProps) => Promise<any>
+  handleLoader?: (props: RequestHandlerProps) => Promise<any>
+  handleAPI?: (props: RequestHandlerProps) => Promise<any>
+  loadMiddleware?: (route: RouteNode) => Promise<any>
+}
 
 type RequestHandlerProps<RouteExtraProps extends Object = {}> = {
   request: Request
@@ -16,83 +25,213 @@ type RequestHandlerProps<RouteExtraProps extends Object = {}> = {
 
 type RequestHandlerResponse = null | string | Response
 
-export function createHandleRequest(
-  options: One.PluginOptions,
-  handlers: {
-    handleSSR?: (props: RequestHandlerProps) => Promise<any>
-    handleLoader?: (props: RequestHandlerProps) => Promise<any>
-    handleAPI?: (props: RequestHandlerProps) => Promise<any>
+async function runMiddlewares(
+  handlers: RequestHandlers,
+  request: Request,
+  route: RouteInfo,
+  getResponse: () => Promise<Response>
+): Promise<Response> {
+  const middlewares = route.middlewares
+
+  if (!middlewares?.length) {
+    return await getResponse()
   }
+  if (!handlers.loadMiddleware) {
+    throw new Error(`No middleware handler configured`)
+  }
+
+  const context: MiddlewareContext = {}
+  async function dispatch(index: number): Promise<Response> {
+    const middlewareModule = middlewares![index]
+
+    // no more middlewares, finish
+    if (!middlewareModule) {
+      return await getResponse()
+    }
+
+    const exported = (await handlers.loadMiddleware!(middlewareModule))?.default as
+      | Middleware
+      | undefined
+    if (!exported) {
+      throw new Error(`No valid export found in middleware: ${middlewareModule.contextKey}`)
+    }
+
+    // go to next middlware
+    const next = async () => {
+      return dispatch(index + 1)
+    }
+
+    // run middlewares, if response returned, exit early
+    const response = await exported({ request, next, context })
+    if (response) {
+      return response
+    }
+
+    // If the middleware returns null/void, keep going
+    return dispatch(index + 1)
+  }
+
+  // Start with the first middleware (index 0).
+  return dispatch(0)
+}
+
+export async function resolveAPIRoute(
+  handlers: RequestHandlers,
+  request: Request,
+  url: URL,
+  route: RouteInfoCompiled
 ) {
-  const manifest = getManifest()
-  if (!manifest) {
-    throw new Error(`No routes manifest`)
+  const { pathname } = url
+  const params = getRouteParams(pathname, route)
+
+  try {
+    return resolveAPIEndpoint(
+      () =>
+        handlers.handleAPI!({
+          request,
+          route,
+          url,
+          loaderProps: {
+            path: pathname,
+            params,
+          },
+        }),
+      request,
+      params || {}
+    )
+  } catch (err) {
+    if (isResponse(err)) {
+      return err
+    }
+
+    if (process.env.NODE_ENV === 'development') {
+      console.error(`\n [one] Error importing API route at ${pathname}:
+
+        ${err}
+      
+        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.
+      `)
+    }
+
+    throw err
   }
+}
 
-  const apiRoutesMap: Record<string, RouteInfo & { compiledRegex: RegExp }> =
-    manifest.apiRoutes.reduce((acc, cur) => {
-      acc[cur.page] = { ...cur, compiledRegex: new RegExp(cur.namedRegex) }
-      return acc
-    }, {})
+export async function resolveLoaderRoute(
+  handlers: RequestHandlers,
+  request: Request,
+  url: URL,
+  route: RouteInfoCompiled
+) {
+  return await runMiddlewares(handlers, request, route, async () => {
+    return await resolveResponse(async () => {
+      const headers = new Headers()
+      headers.set('Content-Type', 'text/javascript')
+
+      try {
+        const loaderResponse = await handlers.handleLoader!({
+          request,
+          route,
+          url,
+          loaderProps: {
+            path: url.pathname,
+            request: route.type === 'ssr' ? request : undefined,
+            params: getLoaderParams(url, route),
+          },
+        })
+
+        return new Response(loaderResponse, {
+          headers,
+        })
+      } catch (err) {
+        // allow throwing a response in a loader
+        if (isResponse(err)) {
+          return err
+        }
+
+        console.error(`Error running loader: ${err}`)
+
+        throw err
+      }
+    })
+  })
+}
 
-  const apiRoutesList = Object.values(apiRoutesMap)
+export async function resolvePageRoute(
+  handlers: RequestHandlers,
+  request: Request,
+  url: URL,
+  route: RouteInfoCompiled
+) {
+  const { pathname, search } = url
+
+  return resolveResponse(async () => {
+    const resolved = await runMiddlewares(handlers, request, route, async () => {
+      return await handlers.handlePage!({
+        request,
+        route,
+        url,
+        loaderProps: {
+          path: pathname + search,
+          params: getLoaderParams(url, route),
+        },
+      })
+    })
+    return resolved
+  })
+}
 
-  // its really common for people to hit refresh a couple times even on accident
-  // sending two ssr requests at once and causing slowdown.
-  // use this to avoid
-  const activeRequests = {}
+export function getURLfromRequestURL(request: Request) {
+  const urlString = request.url || ''
+  return new URL(
+    urlString || '',
+    request.headers.get('host') ? `http://${request.headers.get('host')}` : ''
+  )
+}
 
-  // shouldn't be mapping back and forth...
-  const pageRoutes = manifest.pageRoutes.map((route) => ({
+function compileRouteRegex(route: RouteInfo): RouteInfoCompiled {
+  return {
     ...route,
-    workingRegex: new RegExp(route.namedRegex),
-  }))
+    compiledRegex: new RegExp(route.namedRegex),
+    honoPath: getHonoPath(route.page),
+  }
+}
+
+export function compileManifest(manifest: { pageRoutes: RouteInfo[]; apiRoutes: RouteInfo[] }): {
+  pageRoutes: RouteInfoCompiled[]
+  apiRoutes: RouteInfoCompiled[]
+} {
+  return {
+    pageRoutes: manifest.pageRoutes.map(compileRouteRegex),
+    apiRoutes: manifest.apiRoutes.map(compileRouteRegex),
+  }
+}
+
+// in dev mode we do it more simply:
+export function createHandleRequest(handlers: RequestHandlers) {
+  const manifest = getManifest()
+  if (!manifest) {
+    throw new Error(`No routes manifest`)
+  }
+  const compiledManifest = compileManifest(manifest)
 
   return {
     manifest,
     handler: async function handleRequest(request: Request): Promise<RequestHandlerResponse> {
-      const urlString = request.url || ''
-      const url = new URL(
-        urlString || '',
-        request.headers.get('host') ? `http://${request.headers.get('host')}` : ''
-      )
+      const url = getURLfromRequestURL(request)
       const { pathname, search } = url
 
-      if (process.env.NODE_ENV !== 'production') {
-        if (activeRequests[pathname]) {
-          return await activeRequests[pathname]
-        }
-      }
-
       if (pathname === '/__vxrnhmr' || pathname.startsWith('/@')) {
         return null
       }
 
       if (handlers.handleAPI) {
-        const apiRoute = apiRoutesList.find((route) => {
-          const regex = route.compiledRegex
-          return regex.test(pathname)
+        const apiRoute = compiledManifest.apiRoutes.find((route) => {
+          return route.compiledRegex.test(pathname)
         })
-
         if (apiRoute) {
-          const params = getRouteParams(pathname, apiRoute)
-
-          try {
-            return await handlers.handleAPI({
-              request,
-              route: apiRoute,
-              url,
-              loaderProps: {
-                path: pathname,
-                params,
-              },
-            })
-          } catch (err) {
-            if (isResponse(err)) {
-              return err
-            }
-            throw err
-          }
+          return await resolveAPIRoute(handlers, request, url, apiRoute)
         }
       }
 
@@ -106,51 +245,20 @@ export function createHandleRequest(
         if (isClientRequestingNewRoute) {
           const originalUrl = getPathFromLoaderPath(pathname)
 
-          const finalUrl = new URL(originalUrl, url.origin)
-
-          for (const route of pageRoutes) {
+          for (const route of compiledManifest.pageRoutes) {
             if (route.file === '') {
               // ignore not found route
               // TODO improve/remove when not found is fixed
               continue
             }
 
-            if (!route.workingRegex.test(finalUrl.pathname)) {
-              continue
-            }
+            const finalUrl = new URL(originalUrl, url.origin)
 
-            if (process.env.NODE_ENV === 'development') {
-              console.info(` ❶ Running loader for route: ${finalUrl.pathname}`)
+            if (!route.compiledRegex.test(finalUrl.pathname)) {
+              continue
             }
 
-            const headers = new Headers()
-            headers.set('Content-Type', 'text/javascript')
-
-            try {
-              const loaderResponse = await handlers.handleLoader({
-                request,
-                route,
-                url,
-                loaderProps: {
-                  path: finalUrl.pathname,
-                  request: route.type === 'ssr' ? request : undefined,
-                  params: getLoaderParams(finalUrl, route),
-                },
-              })
-
-              return new Response(loaderResponse, {
-                headers,
-              })
-            } catch (err) {
-              // allow throwing a response in a loader
-              if (isResponse(err)) {
-                return err
-              }
-
-              console.error(`Error running loader: ${err}`)
-
-              throw err
-            }
+            return resolveLoaderRoute(handlers, request, finalUrl, route)
           }
 
           if (process.env.NODE_ENV === 'development') {
@@ -166,36 +274,12 @@ export function createHandleRequest(
         }
       }
 
-      if (handlers.handleSSR) {
-        const { promise, reject, resolve } = promiseWithResolvers()
-
-        // TODO timeout handler to clear activeRequests and log error
-        activeRequests[pathname] = promise
-
-        try {
-          for (const route of pageRoutes) {
-            if (!route.workingRegex.test(pathname)) {
-              continue
-            }
-
-            const ssrResponse = await handlers.handleSSR({
-              request,
-              route,
-              url,
-              loaderProps: {
-                path: pathname + search,
-                params: getLoaderParams(url, route),
-              },
-            })
-
-            resolve(ssrResponse)
-            return ssrResponse
+      if (handlers.handlePage) {
+        for (const route of compiledManifest.pageRoutes) {
+          if (!route.compiledRegex.test(pathname)) {
+            continue
           }
-        } catch (err) {
-          reject(err)
-          throw err
-        } finally {
-          delete activeRequests[pathname]
+          return resolvePageRoute(handlers, request, url, route)
         }
       }
 
@@ -206,10 +290,10 @@ export function createHandleRequest(
 
 function getLoaderParams(
   url: URL,
-  config: { workingRegex: RegExp; routeKeys: Record<string, string> }
+  config: { compiledRegex: RegExp; routeKeys: Record<string, string> }
 ) {
   const params: Record<string, string> = {}
-  const match = new RegExp(config.workingRegex).exec(url.pathname)
+  const match = new RegExp(config.compiledRegex).exec(url.pathname)
   if (match?.groups) {
     for (const [key, value] of Object.entries(match.groups)) {
       const namedKey = config.routeKeys[key]

package/src/createMiddleware.ts

@@ -0,0 +1,14 @@
+type MaybeResponse = Response | void | null
+type RequestResponse = MaybeResponse | Promise<MaybeResponse>
+
+export interface MiddlewareContext {}
+
+export type Middleware = (props: {
+  request: Request
+  next: () => Promise<MaybeResponse>
+  context: MiddlewareContext
+}) => RequestResponse
+
+export function createMiddleware(middleware: Middleware) {
+  return middleware
+}

package/src/getRoutes.ts

@@ -16,10 +16,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?: 'sync'
   platformRoutes?: boolean
   platform?: string
@@ -27,6 +23,7 @@ export type Options = {
 
 type DirectoryNode = {
   layout?: RouteNode[]
+  middleware?: RouteNode
   files: Map<string, RouteNode[]>
   subdirectories: Map<string, DirectoryNode>
 }
@@ -65,16 +62,6 @@ export function getRoutes(
   return rootNode
 }
 
-export function getExactRoutes(
-  contextModule: One.RouteContext,
-  options: Options = {}
-): RouteNode | null {
-  return getRoutes(contextModule, {
-    ...options,
-    skipGenerated: true,
-  })
-}
-
 /**
  * Converts the One.RouteContext keys (file paths) into a directory tree.
  */
@@ -128,6 +115,7 @@ function getDirectoryTree(contextModule: One.RouteContext, options: Options) {
           return contextModule(filePath)
         }
       },
+
       contextKey: filePath,
       route: '', // This is overwritten during hoisting based upon the _layout
       dynamic: null,
@@ -187,6 +175,8 @@ function getDirectoryTree(contextModule: One.RouteContext, options: Options) {
           node = getLayoutNode(node, options)
           directory.layout[meta.specificity] = node
         }
+      } else if (meta.isMiddleware) {
+        directory.middleware = node
       } else if (type === 'api') {
         const fileKey = `${route}+api`
         let nodes = directory.files.get(fileKey)
@@ -246,7 +236,6 @@ function getDirectoryTree(contextModule: One.RouteContext, options: Options) {
 
   /**
    * If there are no top-level _layout, add a default _layout
-   * While this is a generated route, it will still be generated even if skipGenerated is true.
    */
   if (!rootDirectory.layout) {
     rootDirectory.layout = [
@@ -267,12 +256,11 @@ function getDirectoryTree(contextModule: One.RouteContext, options: Options) {
   }
 
   // Only include the sitemap if there are routes.
-  if (!options.skipGenerated) {
-    if (hasRoutes) {
-      appendSitemapRoute(rootDirectory)
-    }
-    appendNotFoundRoute(rootDirectory)
+  if (hasRoutes) {
+    appendSitemapRoute(rootDirectory)
   }
+  appendNotFoundRoute(rootDirectory)
+
   return rootDirectory
 }
 
@@ -285,7 +273,8 @@ function flattenDirectoryTreeToRoutes(
   /* The nearest _layout file in the directory tree */
   layout?: RouteNode,
   /* Route names are relative to their layout */
-  pathToRemove = ''
+  pathToRemove = '',
+  parentMiddlewares?: RouteNode[]
 ) {
   /**
    * This directory has a _layout file so it becomes the new target for hoisting routes.
@@ -299,10 +288,6 @@ function flattenDirectoryTreeToRoutes(
       previousLayout.children.push(layout)
     }
 
-    if (options.internal_stripLoadRoute) {
-      delete (layout as any).loadRoute
-    }
-
     // `route` is the absolute pathname. We need to make this relative to the last _layout
     const newRoute = layout.route.replace(pathToRemove, '')
     pathToRemove = layout.route ? `${layout.route}/` : ''
@@ -315,6 +300,10 @@ function flattenDirectoryTreeToRoutes(
   // This should never occur as there will always be a root layout, but it makes the type system happy
   if (!layout) throw new Error('One Internal Error: No nearest layout')
 
+  const middlewares = directory.middleware
+    ? [...(parentMiddlewares || []), directory.middleware]
+    : parentMiddlewares
+
   for (const routes of directory.files.values()) {
     // TODO(Platform Routes): We need to pick the most specific layout and ensure that all routes have a non-platform route.
     const routeNode = getMostSpecific(routes)
@@ -322,17 +311,14 @@ function flattenDirectoryTreeToRoutes(
     // `route` is the absolute pathname. We need to make this relative to the nearest layout
     routeNode.route = routeNode.route.replace(pathToRemove, '')
     routeNode.dynamic = generateDynamic(routeNode.route)
-
-    if (options.internal_stripLoadRoute) {
-      delete (routeNode as any).loadRoute
-    }
+    routeNode.middlewares = middlewares
 
     layout.children.push(routeNode)
   }
 
   // Recursively flatten the subdirectories
   for (const child of directory.subdirectories.values()) {
-    flattenDirectoryTreeToRoutes(child, options, layout, pathToRemove)
+    flattenDirectoryTreeToRoutes(child, options, layout, pathToRemove, middlewares)
   }
 
   return layout
@@ -348,6 +334,7 @@ function getFileMeta(key: string, options: Options) {
   const filenameWithoutExtensions = removeSupportedExtensions(filename)
 
   const isLayout = filenameWithoutExtensions.startsWith('_layout')
+  const isMiddleware = filenameWithoutExtensions.startsWith('_middleware')
 
   const [_fullname, renderModeFound] = filename.match(/\+(api|ssg|ssr|spa)\.(\w+\.)?[jt]sx?$/) || []
   const renderMode = renderModeFound as 'api' | One.RouteRenderMode | undefined
@@ -407,6 +394,7 @@ function getFileMeta(key: string, options: Options) {
     route,
     specificity,
     isLayout,
+    isMiddleware,
     renderMode,
   }
 }
@@ -591,19 +579,17 @@ function crawlAndAppendInitialRoutesAndEntryFiles(
     })
     let initialRouteName = childMatchingGroup?.route
     // We may strip loadRoute during testing
-    if (!options.internal_stripLoadRoute) {
-      const loaded = node.loadRoute()
-      if (loaded?.unstable_settings) {
-        // Allow unstable_settings={ initialRouteName: '...' } to override the default initial route name.
-        initialRouteName = loaded.unstable_settings.initialRouteName ?? initialRouteName
+    const loaded = node.loadRoute()
+    if (loaded?.unstable_settings) {
+      // Allow unstable_settings={ initialRouteName: '...' } to override the default initial route name.
+      initialRouteName = loaded.unstable_settings.initialRouteName ?? initialRouteName
 
-        if (groupName) {
-          // Allow unstable_settings={ 'custom': { initialRouteName: '...' } } to override the less specific initial route name.
-          const groupSpecificInitialRouteName =
-            loaded.unstable_settings?.[groupName]?.initialRouteName
+      if (groupName) {
+        // Allow unstable_settings={ 'custom': { initialRouteName: '...' } } to override the less specific initial route name.
+        const groupSpecificInitialRouteName =
+          loaded.unstable_settings?.[groupName]?.initialRouteName
 
-          initialRouteName = groupSpecificInitialRouteName ?? initialRouteName
-        }
+        initialRouteName = groupSpecificInitialRouteName ?? initialRouteName
       }
     }
 

package/src/index.ts

@@ -13,6 +13,9 @@ export { router } from './imperative-api'
 export { createRoute, route } from './createRoute'
 export { onClientLoaderResolve } from './clientLoaderResolver'
 
+// middleware
+export { createMiddleware, type Middleware } from './createMiddleware'
+
 // internals
 export { render } from './render'
 export { Root } from './Root'

package/src/router/router.ts

@@ -62,6 +62,7 @@ export function initialize(
     ignoreEntryPoints: true,
     platform: Platform.OS,
   })
+
   rootComponent = routeNode ? getQualifiedRouteComponent(routeNode) : Fragment
 
   if (!routeNode && process.env.NODE_ENV === 'production') {

package/src/serve-worker.ts

@@ -3,6 +3,7 @@ import { oneServe } from './server/oneServe'
 import type { One } from './vite/types'
 import { setupBuildInfo } from './server/setupBuildOptions'
 import { ensureExists } from './utils/ensureExists'
+import { Hono } from 'hono'
 
 export async function serve(buildInfo: One.BuildInfo) {
   setupBuildInfo(buildInfo)
@@ -11,9 +12,13 @@ export async function serve(buildInfo: One.BuildInfo) {
   // TODO make this better, this ensures we get react 19
   process.env.VXRN_REACT_19 = '1'
 
-  const app = await createProdServer(buildInfo.oneOptions)
+  const serverOptions = buildInfo.oneOptions.server || {}
 
-  await oneServe(buildInfo.oneOptions, buildInfo.oneOptions, buildInfo, app, false)
+  const app = new Hono()
+
+  await createProdServer(app, serverOptions)
+
+  await oneServe(buildInfo.oneOptions, buildInfo, app, false)
 
   return app
 }

package/src/serve.ts

@@ -33,21 +33,20 @@ export async function serve(args: VXRNOptions['server'] = {}) {
   process.env.VXRN_REACT_19 = '1'
 
   return await vxrnServe({
-    server: {
-      // fallback to one plugin
-      ...oneOptions.server,
-      // override with any flags given to cli
-      ...removeUndefined({
-        port: args.port ? +args.port : undefined,
-        host: args.host,
-        compress: args.compress,
-        platform: args.platform,
-        cacheHeaders: args.cacheHeaders,
-      }),
+    // fallback to one plugin
+    ...oneOptions.server,
+    // override with any flags given to cli
+    ...removeUndefined({
+      port: args.port ? +args.port : undefined,
+      host: args.host,
+      compress: args.compress,
+      platform: args.platform,
+    }),
+
+    async beforeRegisterRoutes(options, app) {
+      await oneServe(oneOptions, buildInfo, app)
     },
 
-    async beforeStart(options, app) {
-      await oneServe(oneOptions, options, buildInfo, app)
-    },
+    async afterRegisterRoutes(options, app) {},
   })
 }

package/src/server/createRoutesManifest.ts

@@ -11,12 +11,19 @@ export type RouteInfo<TRegex = string> = {
   namedRegex: TRegex
   routeKeys: Record<string, string>
   layouts?: RouteNode[]
+  middlewares?: RouteNode[]
   type: One.RouteType
   isNotFound?: boolean
 }
 
+export type RouteInfoCompiled = RouteInfo & {
+  compiledRegex: RegExp
+  honoPath: string
+}
+
 export type RoutesManifest<TRegex = string> = {
   apiRoutes: RouteInfo<TRegex>[]
+  middlewareRoutes: RouteInfo<TRegex>[]
   pageRoutes: RouteInfo<TRegex>[]
 }