@wix/origami-site 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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": [
@@ -9,7 +9,7 @@
   "scripts": {
     "build": "tsc --noEmit",
     "lint": "oxlint .",
-    "test": "tsc --noEmit -p tsconfig.test.json"
+    "test": "node --test test/*.spec.js && tsc --noEmit -p tsconfig.test.json"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -43,7 +43,8 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "@wix/builder-error-pages": "^1.1.6",
-    "@wix/builder-piler-components": "^1.6.7"
+    "@wix/builder-piler-components": "^1.6.7",
+    "@babel/parser": "^7.25.0"
   },
   "exports": {
     "./server": {
@@ -67,5 +68,5 @@
     },
     "./default-error-404": "./src/default-error-404.jsx"
   },
-  "falconPackageHash": "88d8479096308cdba298b8fe696e53dbd9a3482bd149a332bd45b100"
+  "falconPackageHash": "236041398ac8f5cb5996fd571ab7dbe9f17287f25c51e01599157dc7"
 }

package/src/server/index.d.ts

@@ -70,7 +70,8 @@ export interface AccessHandler {
 }
 
 
-export type { SiteTreeError, RouterServiceError } from './requests/errors.js'
+export { SiteTreeError } from './requests/errors.js'
+export type { RouterServiceError } from './requests/errors.js'
 export function createSite(options: SiteOptions): Promise<OrigamiSite>
 export function readSiteTree(root: string): Promise<SiteRouteTable>
 export function runInRequestContext<T>(ctx: RequestContext, fn: () => Promise<T>): Promise<T>

package/src/server/index.js

@@ -1 +1,2 @@
-export {}
+export { readSiteTree } from './site-tree/readSiteTree.js'
+export { SiteTreeError } from './requests/errors.js'

package/src/server/requests/errors.d.ts

@@ -1,5 +1,6 @@
 export class SiteTreeError extends Error {
   code:
+    | 'NOT_SUPPORTED_YET'                // router pages are not supported in stage 1
     | 'DUPLICATE_URL'                    // two folders give the same URL
     | 'ROUTE_JSON_INVALID'               // not JSON, or a required field missing or of the wrong type
     | 'ROUTE_JSON_MISSING_SERVICE_URL'   // no routerServiceUrl: origami refuses to start
@@ -13,6 +14,7 @@ export class SiteTreeError extends Error {
     | 'NOT_FOUND_HAS_CHILDREN'
     | 'DUPLICATE_POPUP'
     | 'UNSUPPORTED_ACCESS_RULE'          // see section 4
+  constructor(code: SiteTreeError['code'], paths: string[], message: string)
   paths: string[]
 }
 

package/src/server/requests/errors.js

@@ -0,0 +1,13 @@
+export class SiteTreeError extends Error {
+    /**
+     * @param {import('./errors.js').SiteTreeError['code']} code
+     * @param {string[]} paths Paths relative to the site package root.
+     * @param {string} message
+     */
+    constructor(code, paths, message) {
+        super(`SiteTreeError ${code}\n${paths.map(path => `  ${path}`).join('\n')}\n  ${message}`)
+        this.name = 'SiteTreeError'
+        this.code = code
+        this.paths = [...paths]
+    }
+}

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

@@ -0,0 +1,55 @@
+import { relative, resolve, sep } from 'node:path'
+import { readSiteTree, siteRoot } from './readSiteTree.js'
+
+/** Internal live table; adapters supply file events, never a second watcher. */
+export const createSiteTree = root => {
+    const rootPath = siteRoot(root)
+    let dirty = true
+    let closed = false
+    /** @type {Promise<import('@wix/origami-types').SiteRouteTable> | undefined} */
+    let pending
+    /** @type {import('@wix/origami-types').SiteRouteTable | undefined} */
+    let current
+    let signature
+    /** @type {Set<(table: import('@wix/origami-types').SiteRouteTable) => void>} */
+    const listeners = new Set()
+    return {
+        table() {
+            if (closed) return Promise.reject(new Error('Site tree is closed.'))
+            if (dirty) {
+                dirty = false
+                // Serialize rescans, including recovery after a rejected scan.
+                pending = (pending ?? Promise.resolve()).catch(() => {}).then(async () => {
+                    const next = await readSiteTree(rootPath)
+                    const nextSignature = JSON.stringify(next)
+                    if (signature !== nextSignature) {
+                        const hadTable = current !== undefined
+                        current = next
+                        signature = nextSignature
+                        if (hadTable && !closed) for (const listener of listeners) listener(next)
+                    }
+                    return /** @type {import('@wix/origami-types').SiteRouteTable} */ (current)
+                })
+            }
+            return /** @type {Promise<import('@wix/origami-types').SiteRouteTable>} */ (pending)
+        },
+        fileChanged(path) {
+            if (closed) return
+            const changed = resolve(rootPath, path)
+            for (const directory of ['pages', 'popups']) {
+                const suffix = relative(resolve(rootPath, 'src', directory), changed)
+                if (suffix === '' || (suffix !== '..' && !suffix.startsWith(`..${sep}`) && !suffix.startsWith(sep))) dirty = true
+            }
+        },
+        /** @param {(table: import('@wix/origami-types').SiteRouteTable) => void} listener */
+        onTableChange(listener) {
+            if (!closed) listeners.add(listener)
+            return () => { listeners.delete(listener) }
+        },
+        async close() {
+            closed = true
+            listeners.clear()
+            await pending?.catch(() => {})
+        },
+    }
+}

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

@@ -0,0 +1,97 @@
+// Ported from origami-site-runtime/routing/pagesToRoutes.js for the layout 2 tree.
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+import { parse } from '@babel/parser'
+import { SiteTreeError } from '../requests/errors.js'
+
+/** @type {Map<string, { mtimeMs: number, metadata: { title?: string, pageId?: string } }>} */
+const metadataCache = new Map()
+
+const readMetadata = structure => {
+    const ast = parse(readFileSync(structure, 'utf8'), { sourceType: 'module', plugins: ['jsx'] })
+    /** @type {{ title?: string, pageId?: string }} */
+    const metadata = {}
+    // Walk Babel's AST without a runtime dependency on @babel/types.
+    const visit = node => {
+        if (!node || typeof node !== 'object') return
+        if (node.type === 'JSXOpeningElement' && node.name.type === 'JSXIdentifier' && node.name.name === 'Page') {
+            for (const attribute of node.attributes) {
+                if (attribute.type !== 'JSXAttribute') continue
+                if (attribute.name.name === 'id' && attribute.value?.type === 'StringLiteral' && metadata.pageId === undefined)
+                    metadata.pageId = attribute.value.value
+                if (metadata.title !== undefined || attribute.name.name !== 'data' ||
+                    attribute.value?.type !== 'JSXExpressionContainer' ||
+                    attribute.value.expression.type !== 'ObjectExpression') continue
+                const property = attribute.value.expression.properties.find(candidate =>
+                    candidate.type === 'ObjectProperty' && !candidate.computed &&
+                    ((candidate.key.type === 'Identifier' && candidate.key.name === 'title') ||
+                        (candidate.key.type === 'StringLiteral' && candidate.key.value === 'title')))
+                if (property?.value.type === 'StringLiteral') metadata.title = property.value.value
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) value.forEach(visit)
+            else if (value && typeof value === 'object') visit(value)
+        }
+    }
+    visit(ast)
+    return metadata
+}
+
+const pageMetadata = folder => {
+    const structure = resolve(folder, 'structure.jsx')
+    const fallback = basename(folder).replace(/^\(([^()]+)\)$/, '$1')
+    if (!existsSync(structure)) {
+        metadataCache.delete(structure)
+        return { title: fallback }
+    }
+    const { mtimeMs } = statSync(structure)
+    let cached = metadataCache.get(structure)
+    if (cached?.mtimeMs !== mtimeMs) {
+        cached = { mtimeMs, metadata: readMetadata(structure) }
+        metadataCache.set(structure, cached)
+    }
+    return { ...cached.metadata, title: cached.metadata.title ?? fallback }
+}
+
+export const siteRoot = root => {
+    if (typeof root !== 'string' || !root) throw new TypeError('root must be a non-empty string.')
+    return resolve(root)
+}
+
+/** @param {string} root @returns {Promise<import('@wix/origami-types').SiteRouteTable>} */
+export const readSiteTree = async root => {
+    const pagesDir = resolve(siteRoot(root), 'src/pages')
+    /** @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 pathsByUrl = new Map()
+    const walk = (folder, itemPath) => {
+        const entries = readdirSync(folder, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+        const path = `src/${itemPath}`
+        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.')
+        const children = entries.filter(entry => entry.isDirectory() && !entry.name.startsWith('.') &&
+            !['_generated', 'node_modules'].includes(entry.name))
+        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.')
+        if (entries.some(entry => entry.isFile() && !entry.name.startsWith('.'))) {
+            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('/')
+                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: [] })
+            }
+        }
+        for (const child of children) walk(resolve(folder, child.name), `${itemPath}/${child.name}`)
+    }
+    if (existsSync(pagesDir)) walk(pagesDir, 'pages')
+    return { version: 2, pages, routers: [], notFound, popups: [] }
+}