one 1.1.4 → 1.1.269

package/src/serve.ts

@@ -0,0 +1,229 @@
+import './polyfills-server'
+
+import FSExtra from 'fs-extra'
+import type { Hono } from 'hono'
+import Path, { join } from 'node:path'
+import type { VXRNOptions } from 'vxrn'
+import { getServerEntry, serve as vxrnServe } from 'vxrn'
+import { createHandleRequest } from './createHandleRequest'
+import type { RenderAppProps } from './types'
+import { isResponse } from './utils/isResponse'
+import { isStatusRedirect } from './utils/isStatus'
+import { removeUndefined } from './utils/removeUndefined'
+import { resolveAPIRequest } from './vite/resolveAPIRequest'
+import type { One } from './vite/types'
+import { loadUserOneOptions } from './vite/one'
+
+process.on('uncaughtException', (err) => {
+  console.error(`[one] Uncaught exception`, err?.stack || err)
+})
+
+export async function serve(args: VXRNOptions['server'] = {}) {
+  const oneOptions = await loadUserOneOptions('serve')
+
+  // TODO make this better, this ensures we get react 19
+  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,
+        compression: args.compression,
+        platform: args.platform,
+        cacheHeaders: args.cacheHeaders,
+      }),
+
+      async beforeStart(options, app) {
+        await oneOptions.server?.beforeStart?.(options, app)
+        await oneServe(oneOptions, options, app)
+      },
+    },
+  })
+}
+
+async function oneServe(options: One.Options, vxrnOptions: VXRNOptions, app: Hono) {
+  const root = options.root || vxrnOptions.root || '.'
+  const isAPIRequest = new WeakMap<any, boolean>()
+  const toAbsolute = (p: string) => Path.resolve(root, p)
+
+  // add redirects
+  const redirects = options.web?.redirects
+  if (redirects) {
+    for (const redirect of redirects) {
+      app.get(redirect.source, (context) => {
+        const destinationUrl = redirect.destination.replace(/:\w+/g, (param) => {
+          const paramName = param.substring(1)
+          return context.req.param(paramName) || ''
+        })
+        return context.redirect(destinationUrl, redirect.permanent ? 301 : 302)
+      })
+    }
+  }
+
+  const buildInfo = await FSExtra.readJSON(toAbsolute(`dist/buildInfo.json`))
+
+  if (!buildInfo) {
+    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
+  }
+
+  const serverOptions = {
+    ...options,
+    root,
+  }
+
+  const entryServer = getServerEntry(serverOptions)
+  const entry = await import(entryServer)
+
+  const render = entry.default.render as (props: RenderAppProps) => any
+  const apiCJS = options.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')
+        )
+
+        isAPIRequest.set(request, true)
+
+        return resolveAPIRequest(
+          async () => {
+            try {
+              return await import(apiFile)
+            } catch (err) {
+              console.error(`\n [one] Error importing API route at ${apiFile}:
+       
+  ${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.
+
+  🐞 For a better error message run "node" and enter:
+  
+  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}`)
+          }
+
+          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}`)
+          }
+        }
+      },
+    }
+  )
+
+  // preload reading in all the files, for prod performance:
+  const htmlFiles: Record<string, string> = {}
+  for (const key in routeMap) {
+    const info = routeToBuildInfo[key]
+
+    if (info?.type === 'ssr') {
+      // we handle this on each request
+      continue
+    }
+
+    htmlFiles[key] = await FSExtra.readFile(join('dist/client', routeMap[key]), 'utf-8')
+  }
+
+  app.use(async (context, next) => {
+    // serve our generated html files
+    const html = htmlFiles[context.req.path]
+    if (html) {
+      return context.html(html)
+    }
+
+    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') || ''}`
+            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
+              )
+            }
+          }
+
+          return response as Response
+        }
+
+        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']}`)
+    }
+
+    await next()
+  })
+}

package/src/server/createRoutesManifest.ts

@@ -0,0 +1,46 @@
+import { type Options, getRoutes } from '../getRoutes'
+import { getServerManifest } from './getServerManifest'
+import type { RouteNode } from '../Route'
+import type { One } from '../vite/types'
+
+export { type Options } from '../getRoutes'
+
+export type RouteInfo<TRegex = string> = {
+  file: string
+  page: string
+  namedRegex: TRegex
+  routeKeys: Record<string, string>
+  layouts?: RouteNode[]
+  type: One.RouteType
+}
+
+export type RoutesManifest<TRegex = string> = {
+  apiRoutes: RouteInfo<TRegex>[]
+  pageRoutes: RouteInfo<TRegex>[]
+}
+
+function createMockModuleWithContext(map: string[] = []) {
+  const contextModule = (key) => ({ default() {} })
+
+  Object.defineProperty(contextModule, 'keys', {
+    value: () => map,
+  })
+
+  return contextModule as One.RouteContext
+}
+
+export function createRoutesManifest(paths: string[], options: Options): RoutesManifest | null {
+  const routeTree = getRoutes(createMockModuleWithContext(paths), {
+    ...options,
+    preserveApiRoutes: true,
+    ignoreRequireErrors: true,
+    ignoreEntryPoints: true,
+    platform: 'web',
+  })
+
+  if (!routeTree) {
+    throw new Error(`No route tree found in paths: ${JSON.stringify(paths)}`)
+  }
+
+  return getServerManifest(routeTree)
+}

package/src/server/getServerManifest.ts

@@ -0,0 +1,280 @@
+/**
+ * Copyright © 2023 Tamagui LLC.
+ * Copyright © 2023 650 Industries.
+ * Copyright © 2023 Vercel, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Based on https://github.com/vercel/next.js/blob/1df2686bc9964f1a86c444701fa5cbf178669833/packages/next/src/shared/lib/router/utils/route-regex.ts
+ */
+import type { RouteNode } from '../Route'
+import { getContextKey, matchGroupName } from '../matchers'
+import { sortRoutes } from '../sortRoutes'
+import type { One } from '../vite/types'
+
+// TODO: Share these types across cli, server, router, etc.
+export type OneRouterServerManifestV1Route<TRegex = string> = {
+  file: string
+  page: string
+  routeKeys: Record<string, string>
+  namedRegex: TRegex
+  generated?: boolean
+  layouts?: RouteNode[]
+  type: One.RouteType
+  isNotFound?: boolean
+}
+
+export type OneRouterServerManifestV1<TRegex = string> = {
+  apiRoutes: OneRouterServerManifestV1Route<TRegex>[]
+  pageRoutes: OneRouterServerManifestV1Route<TRegex>[]
+}
+
+export interface Group {
+  pos: number
+  repeat: boolean
+  optional: boolean
+}
+
+export interface RouteRegex {
+  groups: Record<string, Group>
+  re: RegExp
+}
+
+function isNotFoundRoute(route: RouteNode) {
+  return Boolean(route.dynamic && route.dynamic[route.dynamic.length - 1].notFound)
+}
+
+// Given a nested route tree, return a flattened array of all routes that can be matched.
+export function getServerManifest(route: RouteNode): OneRouterServerManifestV1 {
+  function getFlatNodes(route: RouteNode, layouts?: RouteNode[]): [string, RouteNode][] {
+    if (route.children.length) {
+      return route.children.flatMap((child) => {
+        return getFlatNodes(child, [...(layouts || []), route])
+      })
+    }
+
+    // API Routes are handled differently to HTML routes because they have no nested behavior.
+    // An HTML route can be different based on parent segments due to layout routes, therefore multiple
+    // copies should be rendered. However, an API route is always the same regardless of parent segments.
+    let key: string
+    if (route.type === 'api') {
+      key = getContextKey(route.contextKey).replace(/\/index$/, '') || '/'
+    } else {
+      const parentSegments = layouts?.flatMap((route) => {
+        const key = getContextKey(route.route).replace(/\/index$/, '') || '/'
+        if (key === '/' || key.startsWith('/(')) {
+          return []
+        }
+        return [key]
+      })
+
+      key = parentSegments + getContextKey(route.route).replace(/\/index$/, '') || '/'
+    }
+
+    return [[key, { ...route, layouts }]]
+  }
+
+  // TODO this could be a lot faster if not functional:
+
+  // Remove duplicates from the runtime manifest which expands array syntax.
+  const flat = getFlatNodes(route)
+    .sort(([, a], [, b]) => sortRoutes(b, a))
+    .reverse()
+
+  // warn on having multiple routes with the same path!
+  const pathToRoute: Record<string, RouteNode> = {}
+  for (const [path, route] of flat) {
+    if (pathToRoute[path]) {
+      console.warn(`\n[one] ❌ Duplicate routes error`)
+      console.warn(`  Multiple routes at the same path! One route will always win over the other.`)
+      console.warn(`    path: ${path}`)
+      console.warn(`    first route: ${pathToRoute[path].contextKey}`)
+      console.warn(`    second route: ${route.contextKey}\n`)
+    }
+    pathToRoute[path] = route
+  }
+
+  const apiRoutes: OneRouterServerManifestV1Route[] = []
+  const pageRoutes: OneRouterServerManifestV1Route[] = []
+
+  for (const [path, node] of flat) {
+    if (node.type === 'api') {
+      apiRoutes.push(getGeneratedNamedRouteRegex(path, node))
+      continue
+    }
+
+    pageRoutes.push(getGeneratedNamedRouteRegex(path, node))
+  }
+
+  return {
+    apiRoutes,
+    pageRoutes,
+  }
+}
+
+function getGeneratedNamedRouteRegex(
+  normalizedRoute: string,
+  node: RouteNode
+): OneRouterServerManifestV1Route {
+  return {
+    ...getNamedRouteRegex(normalizedRoute, node),
+    generated: true,
+    isNotFound: isNotFoundRoute(node),
+  }
+}
+
+function getNamedRouteRegex(
+  normalizedRoute: string,
+  node: RouteNode
+): OneRouterServerManifestV1Route {
+  const result = getNamedRegex(normalizedRoute)
+  return {
+    file: node.contextKey,
+    page: getContextKey(node.route),
+    type: node.type,
+    namedRegex: result.namedRegex,
+    routeKeys: result.routeKeys,
+    layouts: node.layouts,
+  }
+}
+
+/**
+ * Builds a function to generate a minimal routeKey using only a-z and minimal
+ * number of characters.
+ */
+function buildGetSafeRouteKey() {
+  let currentCharCode = 96 // Starting one before 'a' to make the increment logic simpler
+  let currentLength = 1
+
+  return () => {
+    let result = ''
+    let incrementNext = true
+
+    // Iterate from right to left to build the key
+    for (let i = 0; i < currentLength; i++) {
+      if (incrementNext) {
+        currentCharCode++
+        if (currentCharCode > 122) {
+          currentCharCode = 97 // Reset to 'a'
+          incrementNext = true // Continue to increment the next character
+        } else {
+          incrementNext = false
+        }
+      }
+      result = String.fromCharCode(currentCharCode) + result
+    }
+
+    // If all characters are 'z', increase the length of the key
+    if (incrementNext) {
+      currentLength++
+      currentCharCode = 96 // This will make the next key start with 'a'
+    }
+
+    return result
+  }
+}
+
+function removeTrailingSlash(route: string): string {
+  return route.replace(/\/$/, '') || '/'
+}
+
+function getNamedRegex(route: string) {
+  const segments = removeTrailingSlash(route).slice(1).split('/')
+  const getSafeRouteKey = buildGetSafeRouteKey()
+  const routeKeys: Record<string, string> = {}
+
+  const routeSegments = segments
+    .map((segment, index) => {
+      if (segment === '+not-found' && index === segments.length - 1) {
+        segment = '[...not-found]'
+      }
+
+      if (/^\[.*\]$/.test(segment)) {
+        const { name, optional, repeat } = parseParam(segment)
+        // replace non-word characters since they can break the named regex
+        let cleanedKey = name.replace(/\W/g, '')
+        let invalidKey = false
+
+        // check if the key is still invalid and fallback to using a known safe key
+        if (cleanedKey.length === 0 || cleanedKey.length > 30) {
+          invalidKey = true
+        }
+        if (!Number.isNaN(Number.parseInt(cleanedKey.slice(0, 1), 10))) {
+          invalidKey = true
+        }
+
+        // Prevent duplicates after sanitizing the key
+        if (cleanedKey in routeKeys) {
+          invalidKey = true
+        }
+
+        if (invalidKey) {
+          cleanedKey = getSafeRouteKey()
+        }
+
+        routeKeys[cleanedKey] = name
+        return repeat
+          ? optional
+            ? `(?:/(?<${cleanedKey}>.+?))?`
+            : `/(?<${cleanedKey}>.+?)`
+          : `/(?<${cleanedKey}>[^/]+?)`
+      }
+
+      if (insideParensRegex.test(segment)) {
+        const groupName = matchGroupName(segment)!
+          .split(',')
+          .map((group) => group.trim())
+          .filter(Boolean)
+
+        if (groupName.length > 1) {
+          const optionalSegment = `\\((?:${groupName.map(escapeStringRegexp).join('|')})\\)`
+          // Make section optional
+          return `(?:/${optionalSegment})?`
+        }
+        // Use simpler regex for single groups
+        return `(?:/${escapeStringRegexp(segment)})?`
+      }
+
+      return `/${escapeStringRegexp(segment)}`
+    })
+    .join('')
+
+  return {
+    namedRegex: `^${routeSegments}(?:/)?$`,
+    routeKeys,
+  }
+}
+
+const insideBracketsRegex = /^\[.*\]$/
+const insideParensRegex = /^\(.*\)$/
+const tripleDotRegex = /^\.\.\./
+const replaceRegex = /[|\\{}()[\]^$+*?.-]/g
+// based on https://github.com/sindresorhus/escape-string-regexp
+const hasRegExpRegex = /[|\\{}()[\]^$+*?.-]/
+
+function escapeStringRegexp(str: string) {
+  // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+  if (hasRegExpRegex.test(str)) {
+    return str.replace(replaceRegex, '\\$&')
+  }
+  return str
+}
+
+export function parseParam(param: string) {
+  let repeat = false
+  let optional = false
+  let name = param
+
+  if (insideBracketsRegex.test(name)) {
+    optional = true
+    name = name.slice(1, -1)
+  }
+
+  if (tripleDotRegex.test(name)) {
+    repeat = true
+    name = name.slice(3)
+  }
+
+  return { name, repeat, optional }
+}

package/src/server-render.tsx

@@ -0,0 +1,24 @@
+// @ts-ignore
+import ReactDOMServer from 'react-dom/server.browser'
+
+export const renderToString = async (app: React.ReactElement, options: { preloads?: string[] }) => {
+  const readableStream = await ReactDOMServer.renderToReadableStream(app, {
+    bootstrapModules: options.preloads,
+  })
+  await readableStream.allReady
+  const out = await streamToString(readableStream)
+  return out
+}
+
+async function streamToString(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const decoder = new TextDecoder('utf-8', { fatal: true })
+  let result = ''
+
+  // @ts-expect-error TS is wrong, see https://nodejs.org/api/webstreams.html#async-iteration
+  for await (const chunk of stream) {
+    result += decoder.decode(chunk, { stream: true })
+  }
+
+  result += decoder.decode()
+  return result
+}

package/src/sortRoutes.ts

@@ -0,0 +1,76 @@
+import type { DynamicConvention, RouteNode } from './Route'
+import { matchGroupName } from './matchers'
+
+function sortDynamicConvention(a: DynamicConvention, b: DynamicConvention) {
+  if (a.deep && !b.deep) {
+    return 1
+  }
+  if (!a.deep && b.deep) {
+    return -1
+  }
+  return 0
+}
+
+export function sortRoutes(a: RouteNode, b: RouteNode): number {
+  if (a.dynamic && !b.dynamic) {
+    return 1
+  }
+  if (!a.dynamic && b.dynamic) {
+    return -1
+  }
+  if (a.dynamic && b.dynamic) {
+    if (a.dynamic.length !== b.dynamic.length) {
+      return b.dynamic.length - a.dynamic.length
+    }
+
+    for (let i = 0; i < a.dynamic.length; i++) {
+      const aDynamic = a.dynamic[i]
+      const bDynamic = b.dynamic[i]
+
+      if (aDynamic.notFound && bDynamic.notFound) {
+        const s = sortDynamicConvention(aDynamic, bDynamic)
+        if (s) {
+          return s
+        }
+      }
+      if (aDynamic.notFound && !bDynamic.notFound) {
+        return 1
+      }
+      if (!aDynamic.notFound && bDynamic.notFound) {
+        return -1
+      }
+
+      const s = sortDynamicConvention(aDynamic, bDynamic)
+      if (s) {
+        return s
+      }
+    }
+    return 0
+  }
+
+  const aIndex = a.route === 'index' || matchGroupName(a.route) != null
+  const bIndex = b.route === 'index' || matchGroupName(b.route) != null
+
+  if (aIndex && !bIndex) {
+    return -1
+  }
+  if (!aIndex && bIndex) {
+    return 1
+  }
+
+  return a.route.length - b.route.length
+}
+
+export function sortRoutesWithInitial(initialRouteName?: string) {
+  return (a: RouteNode, b: RouteNode): number => {
+    if (initialRouteName) {
+      if (a.route === initialRouteName) {
+        return -1
+      }
+      if (b.route === initialRouteName) {
+        return 1
+      }
+    }
+    return sortRoutes(a, b)
+  }
+}

package/src/typed-routes/generateRouteTypes.ts

@@ -0,0 +1,18 @@
+import FSExtra from 'fs-extra'
+import { writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { globbedRoutesToRouteContext } from '../useViteRoutes'
+import { globDir } from '../utils/globDir'
+import { getTypedRoutesDeclarationFile } from './getTypedRoutesDeclarationFile'
+
+export async function generateRouteTypes(outFile: string) {
+  const routePaths = globDir('app')
+  const routes = routePaths.reduce((acc, cur) => {
+    acc[cur] = {}
+    return acc
+  }, {})
+  const context = globbedRoutesToRouteContext(routes)
+  const declarations = getTypedRoutesDeclarationFile(context)
+  await FSExtra.ensureDir(dirname(outFile))
+  await writeFile(outFile, declarations)
+}