@wix/origami-site-express 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site-express",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Run an exported Wix origami site on Node with Express and Vite.",
   "type": "module",
   "files": [
@@ -65,5 +65,5 @@
       ]
     }
   },
-  "falconPackageHash": "455a5d4751b360861bad538b9622e269cf9952063df493f85de30eb9"
+  "falconPackageHash": "6752e2f2177eb2d994c6179584089e00c5367134074ffcb8d5b74572"
 }

package/src/adapter/driver.js

@@ -12,7 +12,7 @@ async function spawnBin(command, root, env) {
     const { spawn } = await import('node:child_process')
     const child = spawn(process.execPath, [binPath(root), command], {
         cwd: root, stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, ...env, ...(command === 'start' ? { NODE_ENV: 'production' } : {}) },
+        env: { ...process.env, ...env, ...(command === 'dev' ? {} : { NODE_ENV: 'production' }) },
     })
     let output = ''
     child.stdout.on('data', chunk => { output += chunk })

package/src/server/currentSite.js

@@ -5,7 +5,7 @@
  * Vite's module runner: a linked core (outside node_modules) comes back as a new namespace object after an
  * edit; an installed one loads once. A failed createSite is retried by the next request.
  * @param {{ loadCore: () => Promise<any>, create: (core: any) => Promise<OrigamiSite> }} options
- * @returns {{ currentSite: () => Promise<OrigamiSite>, site: () => OrigamiSite | undefined,
+ * @returns {{ currentSite: () => Promise<OrigamiSite>, site: () => OrigamiSite | undefined, fileChanged: (path: string) => void,
  *   siteTree: { table: () => ReturnType<OrigamiSite['table']>, onTableChange: OrigamiSite['onTableChange'] } }} */
 export function createCurrentSite({ loadCore, create }) {
     /** @type {{ core?: unknown, site?: OrigamiSite }} */
@@ -16,6 +16,8 @@ export function createCurrentSite({ loadCore, create }) {
     const listeners = new Set()
     /** @type {(() => void) | undefined} */
     let unsubscribe
+    /** Files changed while a site is being created: it may have read them already, or not. */
+    const changedWhileCreating = new Set()
     async function currentSite() {
         const core = await loadCore()
         if (core === current.core && current.site) return current.site
@@ -27,6 +29,8 @@ export function createCurrentSite({ loadCore, create }) {
                 current = {}
                 const created = await create(core)
                 current = { core, site: created }
+                for (const path of changedWhileCreating) created.fileChanged(path)
+                changedWhileCreating.clear()
                 unsubscribe?.()
                 unsubscribe = created.onTableChange(table => { for (const listener of listeners) listener(table) })
                 return created
@@ -37,8 +41,14 @@ export function createCurrentSite({ loadCore, create }) {
     }
     return {
         currentSite,
-        /** The site already created, if any: for watcher events, which must not create one. */
+        /** The site already created, if any: for shutdown, which must not create one. */
         site: () => current.site,
+        /** Watcher events: to the current site, or held for the one being created. Never creates one.
+         * @param {string} path */
+        fileChanged(path) {
+            if (creating) changedWhileCreating.add(path)
+            else current.site?.fileChanged(path)
+        },
         /** What origamiVitePlugins reads. It was given once, at Vite startup, so it follows each new site. */
         siteTree: {
             table: async () => (await currentSite()).table(),

package/src/server/dev.js

@@ -12,12 +12,12 @@ 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_'])
+    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, siteTree } = createCurrentSite({
+    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) }),
     })
@@ -35,7 +35,7 @@ export async function dev({ root }) {
         // where `exports` is not defined. Add any CommonJS package the core starts importing.
         ssr: { external: ['@wix/origami-types'] },
     })
-    vite.watcher.on('all', (_event, path) => site()?.fileChanged(path))
+    vite.watcher.on('all', (_event, path) => fileChanged(path))
     const app = express()
     app.disable('x-powered-by')
     app.use(vite.middlewares)
@@ -47,5 +47,5 @@ export async function dev({ root }) {
         })), resolution.embeds),
     }))
     httpServer.on('request', app)
-    await serve(httpServer, { port: port(), host: host('dev'), onClose: async () => { await vite.close(); await site()?.close() } })
+    await serve(httpServer, { port: port(env), host: host('dev', env), onClose: async () => { await vite.close(); await site()?.close() } })
 }

package/src/server/env.js

@@ -7,9 +7,10 @@ export function siteOptions(env) {
     }
 }
 
-export const port = () => Number(process.env.PORT ?? 3000)
+/** An empty PORT= means the default, not a random port. @param {Record<string, string | undefined>} [env] */
+export const port = (env = process.env) => Number(env.PORT || 3000)
 
 /** Dev serves the site's source through Vite, so it stays on this machine unless HOST says otherwise.
  * 127.0.0.1, not localhost: on macOS localhost binds only ::1. Start listens on every interface so the deployed site is reachable.
- * @param {'dev' | 'prod'} mode */
-export const host = mode => process.env.HOST || (mode === 'dev' ? '127.0.0.1' : undefined)
+ * @param {'dev' | 'prod'} mode @param {Record<string, string | undefined>} [env] */
+export const host = (mode, env = process.env) => env.HOST || (mode === 'dev' ? '127.0.0.1' : undefined)