@wix/origami-site-express 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site-express",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Run an exported Wix origami site on Node with Express and Vite.",
   "type": "module",
   "files": [
@@ -34,7 +34,7 @@
     "@vitejs/plugin-react": "^6.1.1",
     "express": "^5.2.1",
     "vite": "^8.1.0",
-    "@wix/origami-bi": "0.9.0"
+    "@wix/origami-bi": "0.10.0"
   },
   "peerDependencies": {
     "@wix/origami-site": "^1.0.0"
@@ -67,5 +67,5 @@
       ]
     }
   },
-  "falconPackageHash": "7a1fd4ba5b7357050b8ee7ad702f2e43679cb9f8745811cb1cc40d8c"
+  "falconPackageHash": "7b2399e27e28ffe108d074ccf265385d853659a4d40b03dfef29d720"
 }

package/src/server/build.js

@@ -1,3 +1,4 @@
+import { trackStep } from '@wix/origami-bi'
 import { rm } from 'node:fs/promises'
 import { join } from 'node:path'
 import { build as viteBuild } from 'vite'
@@ -11,20 +12,30 @@ export async function build({ root }) {
     const { readSiteTree, writeBuiltTable } = await importCoreServer(root)
     const { origamiVitePlugins } = await importCoreBuild(root)
     // One read: the browser's page list and the server's routes come from the same table.
-    const table = await readSiteTree(root)
+    const table = await trackStep('step', 'read_site_tree', {}, async row => {
+        const table = await readSiteTree(root)
+        row?.update({ step_details: { pages: table.pages.length, routes: table.pages.length + table.routers.length } })
+        return table
+    })
     // A build that fails after Vite replaced dist/client must not leave the old table for start to accept.
     await rm(join(root, 'dist/server/origami-routes.json'), { force: true })
     const siteTree = { table: async () => table, onTableChange: () => () => {} }
-    await viteBuild({
-        root, configFile: false, mode: 'production',
-        plugins: [...origamiVitePlugins({ root, siteTree }), react()],
-        // Vite 8 minifies CSS with lightningcss, which rejects rules browsers just ignore, like the Menu CSS of
-        // @wix/editor-react-components: `@property --wix-menu-dropdown-anchor` without the required initial-value.
-        // errorRecovery drops such rules with a warning. It applies to all CSS: a site's own invalid CSS also builds, with
-        // the broken rules dropped and warned about. Remove it once that package ships valid CSS.
-        css: { lightningcss: { errorRecovery: true } },
-        build: { outDir: 'dist/client', emptyOutDir: true, manifest: true, rolldownOptions: { input: CLIENT_ENTRY } },
+    await trackStep('step', 'vite_build', {}, async row => {
+        const result = await viteBuild({
+            root, configFile: false, mode: 'production',
+            plugins: [...origamiVitePlugins({ root, siteTree }), react()],
+            // Vite 8 minifies CSS with lightningcss, which rejects rules browsers just ignore, like the Menu CSS of
+            // @wix/editor-react-components: `@property --wix-menu-dropdown-anchor` without the required initial-value.
+            // errorRecovery drops such rules with a warning. It applies to all CSS: a site's own invalid CSS also builds, with
+            // the broken rules dropped and warned about. Remove it once that package ships valid CSS.
+            css: { lightningcss: { errorRecovery: true } },
+            build: { outDir: 'dist/client', emptyOutDir: true, manifest: true, rolldownOptions: { input: CLIENT_ENTRY } },
+        })
+        const outputs = Array.isArray(result) ? result : 'output' in result ? [result] : []
+        const modules = new Set(outputs.flatMap(output => output.output.flatMap(chunk => chunk.type === 'chunk' ? Object.keys(chunk.modules) : [])))
+        row?.update({ step_details: { modules: modules.size } })
     })
     // Last, so a failed client build never leaves a table that start would accept.
-    await writeBuiltTable(join(root, 'dist/server'), table)
+    await trackStep('step', 'write_route_table', { step_details: { routes: table.pages.length + table.routers.length } },
+        () => writeBuiltTable(join(root, 'dist/server'), table))
 }

package/src/server/core.js

@@ -1,3 +1,5 @@
+import { readFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
 import { createRequire } from 'node:module'
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
@@ -10,6 +12,11 @@ export function coreEntry(root, entry) {
 
 /** @param {string} root @returns {Promise<typeof import('@wix/origami-site/server')>} */
 export const importCoreServer = root => import(pathToFileURL(coreEntry(root, 'server')).href)
+
+/** @param {string} root */
+export async function coreVersion(root) {
+    return JSON.parse(await readFile(resolve(dirname(coreEntry(root, 'server')), '../../package.json'), 'utf8')).version
+}
 /** @param {string} root @returns {Promise<typeof import('@wix/origami-site/node')>} */
 export const importCoreNode = root => import(pathToFileURL(coreEntry(root, 'node')).href)
 /** @param {string} root @returns {Promise<typeof import('@wix/origami-site/build')>} */

package/src/server/currentSite.js

@@ -1,3 +1,5 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
 /** @typedef {import('@wix/origami-site/types').OrigamiSite} OrigamiSite */
 /** @typedef {Awaited<ReturnType<OrigamiSite['table']>>} SiteRouteTable */
 
@@ -8,6 +10,8 @@
  * @returns {{ currentSite: () => Promise<OrigamiSite>, site: () => OrigamiSite | undefined, fileChanged: (path: string) => void,
  *   siteTree: { table: () => ReturnType<OrigamiSite['table']>, onTableChange: OrigamiSite['onTableChange'] } }} */
 export function createCurrentSite({ loadCore, create }) {
+    // Core reloads create the site lazily from requests outside startup; retain the workspace run for its counters.
+    const inContext = AsyncLocalStorage.snapshot()
     /** @type {{ core?: unknown, site?: OrigamiSite }} */
     let current = {}
     /** @type {{ core: unknown, site: Promise<OrigamiSite> } | undefined} */
@@ -27,7 +31,7 @@ export function createCurrentSite({ loadCore, create }) {
             const site = (async () => {
                 await current.site?.close()
                 current = {}
-                const created = await create(core)
+                const created = await inContext(() => create(core))
                 current = { core, site: created }
                 for (const path of changedWhileCreating) created.fileChanged(path)
                 changedWhileCreating.clear()

package/src/server/dev.js

@@ -1,8 +1,9 @@
+import { trackStep } from '@wix/origami-bi'
 import { createServer as createHttpServer } from 'node:http'
 import express from 'express'
 import { createServer as createViteServer, isRunnableDevEnvironment, loadEnv } from 'vite'
 import react from '@vitejs/plugin-react'
-import { coreEntry, importCoreBuild, importCoreNode, importCoreServer } from './core.js'
+import { coreEntry, importCoreBuild, importCoreNode, importCoreServer, coreVersion } from './core.js'
 import { catchAll } from './bridge.js'
 import { pageHtml, plantEmbeds } from './shell.js'
 import { host, port, siteOptions } from './env.js'
@@ -12,40 +13,43 @@ import { createCurrentSite } from './currentSite.js'
 /** `origami-site-express dev`: Vite in middleware mode, Express, and the core in dev mode, all live.
  * @param {{ root: string }} options */
 export async function dev({ root }) {
-    const env = loadEnv('development', root, ['VITE_', 'ORIGAMI_', 'PORT', 'HOST'])
-    const { errorResponse, serializePageData } = await importCoreServer(root)
-    const { origamiVitePlugins } = await importCoreBuild(root)
-    const node = await importCoreNode(root)
-    const serverEntry = coreEntry(root, 'server')
-    const { currentSite, site, fileChanged, siteTree } = createCurrentSite({
-        loadCore: () => isRunnableDevEnvironment(vite.environments.ssr) ? vite.environments.ssr.runner.import(serverEntry) : vite.ssrLoadModule(serverEntry),
-        create: core => core.createSite({ root, mode: 'dev', ...siteOptions(env) }),
+    return trackStep('step', 'dev_start', {}, async row => {
+        const env = loadEnv('development', root, ['VITE_', 'ORIGAMI_', 'PORT', 'HOST'])
+        const { errorResponse, serializePageData } = await importCoreServer(root)
+        const { origamiVitePlugins } = await importCoreBuild(root)
+        const node = await importCoreNode(root)
+        row?.update({ step_details: { core_version: await coreVersion(root), port_kind: env.PORT ? 'custom' : 'default' } })
+        const serverEntry = coreEntry(root, 'server')
+        const { currentSite, site, fileChanged, siteTree } = createCurrentSite({
+            loadCore: () => isRunnableDevEnvironment(vite.environments.ssr) ? vite.environments.ssr.runner.import(serverEntry) : vite.ssrLoadModule(serverEntry),
+            create: core => core.createSite({ root, mode: 'dev', ...siteOptions(env) }),
+        })
+        const httpServer = createHttpServer()
+        const vite = await createViteServer({
+            root, configFile: false, appType: 'custom', mode: 'development',
+            // HMR on the site's own port: without it Vite opens a second port, and two sites would collide.
+            server: { middlewareMode: true, ws: { server: httpServer } },
+            // React after ours: origami:jsx-checks is enforce 'pre', so our Babel checks see the source first.
+            plugins: [...origamiVitePlugins({ root, siteTree }), react()],
+            // No index.html lists the pages, so Vite can't scan them up front. Without this, the first visit to a lazily
+            // loaded page finds new dependencies, re-optimizes them and reloads, and the page briefly runs two Reacts.
+            optimizeDeps: { entries: ['src/site/_generated/client.jsx', 'src/pages/**/_generated/index.jsx'] },
+            // The core's CommonJS dependencies go to Node. Linked (as in this repo), Vite would inline them as ESM,
+            // where `exports` is not defined. Add any CommonJS package the core starts importing.
+            ssr: { external: ['@wix/origami-types', '@wix/origami-bi'] },
+        })
+        vite.watcher.on('all', (_event, path) => fileChanged(path))
+        const app = express()
+        app.disable('x-powered-by')
+        app.use(vite.middlewares)
+        app.use(catchAll({
+            mode: 'dev', errorResponse, node, getSite: currentSite,
+            renderPage: async (resolution, request) => plantEmbeds(await vite.transformIndexHtml(new URL(request.url).pathname, pageHtml(resolution, {
+                serializePageData,
+                body: '<script type="module" src="/src/site/_generated/client.jsx"></script>',
+            })), resolution.embeds),
+        }))
+        httpServer.on('request', app)
+        await serve(httpServer, { port: port(env), host: host('dev', env), onClose: async () => { await vite.close(); await site()?.close() } })
     })
-    const httpServer = createHttpServer()
-    const vite = await createViteServer({
-        root, configFile: false, appType: 'custom', mode: 'development',
-        // HMR on the site's own port: without it Vite opens a second port, and two sites would collide.
-        server: { middlewareMode: true, ws: { server: httpServer } },
-        // React after ours: origami:jsx-checks is enforce 'pre', so our Babel checks see the source first.
-        plugins: [...origamiVitePlugins({ root, siteTree }), react()],
-        // No index.html lists the pages, so Vite can't scan them up front. Without this, the first visit to a lazily
-        // loaded page finds new dependencies, re-optimizes them and reloads, and the page briefly runs two Reacts.
-        optimizeDeps: { entries: ['src/site/_generated/client.jsx', 'src/pages/**/_generated/index.jsx'] },
-        // The core's CommonJS dependencies go to Node. Linked (as in this repo), Vite would inline them as ESM,
-        // where `exports` is not defined. Add any CommonJS package the core starts importing.
-        ssr: { external: ['@wix/origami-types'] },
-    })
-    vite.watcher.on('all', (_event, path) => fileChanged(path))
-    const app = express()
-    app.disable('x-powered-by')
-    app.use(vite.middlewares)
-    app.use(catchAll({
-        mode: 'dev', errorResponse, node, getSite: currentSite,
-        renderPage: async (resolution, request) => plantEmbeds(await vite.transformIndexHtml(new URL(request.url).pathname, pageHtml(resolution, {
-            serializePageData,
-            body: '<script type="module" src="/src/site/_generated/client.jsx"></script>',
-        })), resolution.embeds),
-    }))
-    httpServer.on('request', app)
-    await serve(httpServer, { port: port(env), host: host('dev', env), onClose: async () => { await vite.close(); await site()?.close() } })
 }

package/src/server/prod.js

@@ -1,8 +1,9 @@
+import { trackStep } from '@wix/origami-bi'
 import { existsSync } from 'node:fs'
 import { createServer } from 'node:http'
 import { join } from 'node:path'
 import express from 'express'
-import { importCoreNode, importCoreServer } from './core.js'
+import { importCoreNode, importCoreServer, coreVersion } from './core.js'
 import { catchAll } from './bridge.js'
 import { pageHtml, plantEmbeds } from './shell.js'
 import { readManifest } from './manifest.js'
@@ -12,21 +13,24 @@ import { serve } from './lifecycle.js'
 /** `origami-site-express start`: the build output and the core in prod mode. No Vite at runtime.
  * @param {{ root: string }} options */
 export async function start({ root }) {
-    // Values already in process.env win, so the host's environment overrides .env.
-    if (existsSync(join(root, '.env'))) process.loadEnvFile(join(root, '.env'))
-    const { readBuiltTable, createSite, errorResponse, serializePageData } = await importCoreServer(root)
-    const node = await importCoreNode(root)
-    const table = await readBuiltTable(join(root, 'dist/server'))
-    const site = await createSite({ root, mode: 'prod', table, ...siteOptions(process.env) })
-    const assetsFor = readManifest(root)
-    const app = express()
-    app.disable('x-powered-by')
-    // index: false keeps / from serving a stray index.html; redirect: false lets /somedir reach the core.
-    app.use('/assets', express.static(join(root, 'dist/client/assets'), { index: false, redirect: false, maxAge: '1y', immutable: true }))
-    app.use(express.static(join(root, 'dist/client'), { index: false, redirect: false }))
-    app.use(catchAll({
-        mode: 'prod', errorResponse, node, getSite: async () => site,
-        renderPage: async resolution => plantEmbeds(pageHtml(resolution, { serializePageData, ...assetsFor(resolution.page) }), resolution.embeds),
-    }))
-    await serve(createServer(app), { port: port(), onClose: () => site.close() })
+    return trackStep('step', 'start_start', {}, async row => {
+        // Values already in process.env win, so the host's environment overrides .env.
+        if (existsSync(join(root, '.env'))) process.loadEnvFile(join(root, '.env'))
+        const { readBuiltTable, createSite, errorResponse, serializePageData } = await importCoreServer(root)
+        const node = await importCoreNode(root)
+        row?.update({ step_details: { core_version: await coreVersion(root), port_kind: process.env.PORT ? 'custom' : 'default' } })
+        const table = await readBuiltTable(join(root, 'dist/server'))
+        const site = await createSite({ root, mode: 'prod', table, ...siteOptions(process.env) })
+        const assetsFor = readManifest(root)
+        const app = express()
+        app.disable('x-powered-by')
+        // index: false keeps / from serving a stray index.html; redirect: false lets /somedir reach the core.
+        app.use('/assets', express.static(join(root, 'dist/client/assets'), { index: false, redirect: false, maxAge: '1y', immutable: true }))
+        app.use(express.static(join(root, 'dist/client'), { index: false, redirect: false }))
+        app.use(catchAll({
+            mode: 'prod', errorResponse, node, getSite: async () => site,
+            renderPage: async resolution => plantEmbeds(pageHtml(resolution, { serializePageData, ...assetsFor(resolution.page) }), resolution.embeds),
+        }))
+        await serve(createServer(app), { port: port(), onClose: () => site.close() })
+    })
 }