@wix/origami-site 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Runs an exported Wix origami site: file-based routing, Wix dynamic pages, popups and build checks. Use with @wix/origami-site-astro or @wix/origami-site-express.",
   "type": "module",
   "files": [
@@ -18,7 +18,9 @@
     "@vitejs/plugin-react": "^5.2.0",
     "postcss": "^8.5.3",
     "jsdom": "^23.0.1",
-    "vitest": "^4.1.11"
+    "vitest": "^4.1.11",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   },
   "publishUnscoped": false,
   "publishConfig": {
@@ -43,19 +45,22 @@
     }
   },
   "dependencies": {
-    "@wix/origami-types": "1.3.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
+    "@wix/origami-types": "1.4.0",
     "@wix/builder-error-pages": "^1.1.6",
     "@wix/builder-piler-components": "^1.6.7",
     "@wix/origami-transforms": "0.1.8",
-    "@babel/parser": "^7.25.0"
+    "@babel/parser": "^7.25.0",
+    "@wix/system-core-components": "^1.3.10"
   },
   "exports": {
     "./server": {
       "types": "./src/server/index.d.ts",
       "default": "./src/server/index.js"
     },
+    "./node": {
+      "types": "./src/node/index.d.ts",
+      "default": "./src/node/index.js"
+    },
     "./browser": {
       "types": "./src/browser/index.d.ts",
       "default": "./src/browser/index.js"
@@ -77,7 +82,14 @@
     }
   },
   "peerDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "vite": "^8"
   },
-  "falconPackageHash": "24c3e9be28422eca894ae970057d12bb43ca7f2b2231d6a51421ada9"
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "falconPackageHash": "4ac96e3424d72ea4e249857636f23b2f4e22af082d644f6b99637eb0"
 }

package/src/node/index.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+
+/** Node request → Web Request, for handle(). Its signal aborts when the client leaves before the response ends. */
+export function toWebRequest(req: IncomingMessage, res: ServerResponse): Request
+/** Web Response → Node response: status, headers with each Set-Cookie kept apart, and the body streamed. HEAD sends no body. */
+export function sendWebResponse(res: ServerResponse, response: Response, options?: { head?: boolean }): Promise<void>

package/src/node/index.js

@@ -0,0 +1,37 @@
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+
+/** Node request → Web Request, for handle(). Its signal aborts when the client leaves before the response ends.
+ * @param {import('node:http').IncomingMessage} req @param {import('node:http').ServerResponse} res */
+export function toWebRequest(req, res) {
+    const headers = new Headers()
+    for (let i = 0; i < req.rawHeaders.length; i += 2) headers.append(req.rawHeaders[i], req.rawHeaders[i + 1])
+    const controller = new AbortController()
+    res.once('close', () => { if (!res.writableFinished) controller.abort() })
+    /** @type {RequestInit & { duplex?: 'half' }} */
+    const init = { method: req.method, headers, signal: controller.signal }
+    if (req.method !== 'GET' && req.method !== 'HEAD') Object.assign(init, { body: Readable.toWeb(req), duplex: 'half' })
+    const host = req.headers.host ?? 'localhost'
+    const origin = new URL(`http://${host}`)
+    // Host must name only a host: a path, ?, # or user@ in it would change what is routed.
+    if (origin.host !== host.toLowerCase().replace(/:80$/, '')) throw new Error(`Bad Host header: ${host}`)
+    // A path is joined, not resolved: new URL('//other.host/x', origin) switches hosts. Absolute and * targets keep only their path.
+    const path = req.url?.startsWith('/') ? req.url : (url => url.pathname + url.search)(new URL(req.url ?? '/', origin))
+    return new Request(origin.origin + path, init)
+}
+
+/** Web Response → Node response: status, headers with each Set-Cookie kept apart, and the body streamed.
+ * HEAD sends no body.
+ * @param {import('node:http').ServerResponse} res @param {Response} response @param {{ head?: boolean }} [options] */
+export async function sendWebResponse(res, response, { head = false } = {}) {
+    res.statusCode = response.status
+    response.headers.forEach((value, key) => { if (key !== 'set-cookie') res.setHeader(key, value) })
+    const cookies = response.headers.getSetCookie()
+    if (cookies.length) res.setHeader('set-cookie', cookies)
+    if (head || !response.body) {
+        await response.body?.cancel()
+        res.end()
+        return
+    }
+    await pipeline(Readable.fromWeb(/** @type {import('node:stream/web').ReadableStream} */ (response.body)), res)
+}

package/src/server/index.d.ts

@@ -78,3 +78,5 @@ export function runInRequestContext<T>(ctx: RequestContext, fn: () => Promise<T>
 export function getRequestContext(): RequestContext
 export function getAccessToken(): Promise<string>
 export function serializePageData(data: PageData): string
+/** The core's plain HTML error page: logs the stack, shows the message in dev only, `cache-control: no-store`. */
+export function errorResponse(error: unknown, options: { status?: 500 | 503; mode: 'dev' | 'prod'; logger?: Logger }): Response

package/src/server/index.js

@@ -3,3 +3,4 @@ export { SiteTreeError } from './requests/errors.js'
 export { createSite, noAccessRules } from './requests/createSite.js'
 export { runInRequestContext, getRequestContext, getAccessToken } from './requests/context.js'
 export { serializePageData } from './requests/pageData.js'
+export { errorResponse } from './requests/errorPage.js'

package/src/server/requests/errorPage.js

@@ -2,14 +2,19 @@ const escapeHtml = value => String(value).replace(/[&<>"']/g, char => ({
     '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
 })[char])
 
-/** Plain HTML: builder-error-pages exports React components, not server HTML. */
-export function errorPage(error, status, mode, logger) {
+/** Plain HTML: builder-error-pages exports React components, not server HTML.
+ * @param {unknown} error @param {{ status?: 500 | 503, mode: 'dev' | 'prod', logger?: import('../index.js').Logger }} options */
+export function errorResponse(error, { status = 500, mode, logger = console }) {
     // Logging must not turn a handled failure into a rejected request.
     try { logger.error(error instanceof Error ? error.stack ?? error.message : String(error)) } catch {}
     const title = status === 503 ? 'Service unavailable' : 'Internal server error'
     const detail = mode === 'dev' ? `<pre>${escapeHtml(error instanceof Error ? error.message : error)}</pre>` : ''
-    return { kind: /** @type {const} */ ('response'), response: new Response(
+    return new Response(
         `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${title}</title></head><body><h1>${title}</h1>${detail}</body></html>`,
         { status, headers: { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' } },
-    ) }
+    )
+}
+
+export function errorPage(error, status, mode, logger) {
+    return { kind: /** @type {const} */ ('response'), response: errorResponse(error, { status, mode, logger }) }
 }

package/src/server/site-tree/readSiteTree.js

@@ -2,10 +2,9 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { basename, resolve } from 'node:path'
 import { parse } from '@babel/parser'
+import { findItems, pageUrl } from '@wix/origami-types'
 import { SiteTreeError } from '../requests/errors.js'
 
-
-
 /** @type {Map<string, { mtimeMs: number, metadata: { title?: string, pageId?: string } }>} */
 const metadataCache = new Map()
 
@@ -63,43 +62,31 @@ export const siteRoot = root => {
 
 /** @param {string} root @returns {Promise<import('@wix/origami-types').SiteRouteTable>} */
 export const readSiteTree = async root => {
-    const pagesDir = resolve(siteRoot(root), 'src/pages')
+    const src = resolve(siteRoot(root), 'src')
     /** @type {import('@wix/origami-types').PageRoute[]} */
     const pages = []
     /** @type {import('@wix/origami-types').SiteNotFoundRoute} */
     let notFound = { key: '@wix/origami-site/default-error-404', title: 'Page not found' }
-    const walk = (folder, itemPath) => {
-        const entries = readdirSync(folder, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+    const pathsByUrl = new Map()
+    const { items, routers } = existsSync(resolve(src, 'pages'))
+        ? findItems(path => readdirSync(resolve(src, path), { withFileTypes: true }), 'pages')
+        : { items: [], routers: [] }
+    if (routers.length) throw new SiteTreeError('NOT_SUPPORTED_YET', [`src/${routers[0]}`], 'Router pages are not supported yet.')
+    for (const itemPath of items) {
         const path = `src/${itemPath}`
-        const isItem = entries.some(entry => entry.isFile() && entry.name === 'version')
-        if (isItem) {
-            const metadata = pageMetadata(folder)
-            if (itemPath === 'pages/error404') notFound = { key: itemPath, itemPath, title: metadata.title }
-            else {
-                const url = '/' + itemPath.split('/').slice(1).filter(segment => !/^\([^()]+\)$/.test(segment)).join('/')
-                pages.push({ key: itemPath, url, itemPath, ...metadata, access: [] })
-            }
+        const metadata = pageMetadata(resolve(src, itemPath))
+        if (itemPath === 'pages/error404') notFound = { key: itemPath, itemPath, title: metadata.title }
+        else {
+            const url = pageUrl(itemPath)
+            const previous = pathsByUrl.get(url)
+            if (previous) throw new SiteTreeError('DUPLICATE_URL', [previous, path], `Both pages serve "${url}".`)
+            pathsByUrl.set(url, path)
+            pages.push({ key: itemPath, url, itemPath, ...metadata, access: [] })
         }
-        const children = entries.filter(entry => entry.isDirectory() && !entry.name.startsWith('.') &&
-            !['_generated', 'node_modules', 'servicesConfigs'].includes(entry.name))
-            .filter(child => walk(resolve(folder, child.name), `${itemPath}/${child.name}`))
-        if (!isItem && !children.length) return false
-        if (/^\[.*\]$/.test(basename(folder)))
-            throw new SiteTreeError('NOT_SUPPORTED_YET', [path], 'Router pages are not supported yet.')
-        if (entries.some(entry => entry.name === 'route.json'))
-            throw new SiteTreeError('NOT_SUPPORTED_YET', [`${path}/route.json`], 'Router pages are not supported yet.')
-        if (itemPath === 'pages/error404' && children.length)
-            throw new SiteTreeError('NOT_FOUND_HAS_CHILDREN', [path, ...children.map(child => `${path}/${child.name}`)],
-                'The not-found page cannot have children.')
-        return true
-    }
-    if (existsSync(pagesDir)) walk(pagesDir, 'pages')
-    const pathsByUrl = new Map()
-    for (const page of pages) {
-        const path = `src/${page.itemPath}`
-        const previous = pathsByUrl.get(page.url)
-        if (previous) throw new SiteTreeError('DUPLICATE_URL', [previous, path], `Both pages serve "${page.url}".`)
-        pathsByUrl.set(page.url, path)
     }
+    const notFoundChildren = pages.filter(page => page.itemPath.startsWith('pages/error404/'))
+    if (notFoundChildren.length)
+        throw new SiteTreeError('NOT_FOUND_HAS_CHILDREN', ['src/pages/error404', ...notFoundChildren.map(page => `src/${page.itemPath}`)],
+            'The not-found page cannot have children.')
     return { version: 2, pages, routers: [], notFound, popups: [] }
 }