@ossy/app 1.11.6 → 1.11.8

package/cli/prerender-react.task.js

@@ -1,29 +1,8 @@
 import path from 'path'
-import url from 'url'
 import fs from 'fs'
 import { rollup } from 'rollup'
-import { BuildPage, buildPrerenderAppConfig } from './render-page.task.js'
 import { pageIdFromHydrateEntryName } from './build-terminal.js'
 
-/**
- * Maps an app route path to the file path express.static will serve for that URL
- * (`/` → `public/index.html`, `/a/b` → `public/a/b/index.html`).
- */
-export function staticHtmlPathForRoute (routePath, publicDir) {
-  const p = typeof routePath === 'string' ? routePath : '/'
-  if (p === '/' || p === '') {
-    return path.join(publicDir, 'index.html')
-  }
-  const segments = p.replace(/^\//, '').split('/').filter(Boolean)
-  return path.join(publicDir, ...segments, 'index.html')
-}
-
-function pathIsPrerenderable (routePath) {
-  if (typeof routePath !== 'string') return false
-  if (!routePath.startsWith('/') || routePath.includes(':')) return false
-  return true
-}
-
 function copyPublicToBuild ({ copyPublicFrom, buildPath }) {
   if (!copyPublicFrom || !fs.existsSync(copyPublicFrom)) return
   const dest = path.join(buildPath, 'public')
@@ -31,10 +10,6 @@ function copyPublicToBuild ({ copyPublicFrom, buildPath }) {
   fs.cpSync(copyPublicFrom, dest, { recursive: true })
 }
 
-function countSettledFailures (results) {
-  return results.filter((r) => r.status === 'rejected').length
-}
-
 async function bundleOneHydratePage ({
   entryName,
   stubPath,
@@ -113,156 +88,37 @@ async function bundleHydratePagesParallel ({
     })
   )
 
-  const failures = countSettledFailures(results)
-
-  return { results, failures }
-}
-
-async function prerenderOnePage ({
-  route,
-  buildTimeConfig,
-  pageList,
-  publicDir,
-}) {
-  const appConfig = buildPrerenderAppConfig({
-    buildTimeConfig,
-    pageList,
-    activeRouteId: route.id,
-    urlPath: route.path,
-  })
-  const html = await BuildPage.handle({
-    route,
-    appConfig,
-    isDevReloadEnabled: false,
-  })
-  const outPath = staticHtmlPathForRoute(route.path, publicDir)
-  fs.mkdirSync(path.dirname(outPath), { recursive: true })
-  fs.writeFileSync(outPath, html, 'utf8')
-}
-
-async function prerenderPagesParallel ({
-  pagesEntryPath,
-  configSourcePath,
-  publicDir,
-  reporter,
-}) {
-  const cfgHref = url.pathToFileURL(path.resolve(configSourcePath)).href
-  const pagesHref = url.pathToFileURL(path.resolve(pagesEntryPath)).href
-
-  const configModule = await import(cfgHref)
-  const pagesModule = await import(pagesHref)
-
-  const buildTimeConfig = configModule?.default ?? configModule ?? {}
-  const pageList = pagesModule?.default ?? []
-
-  const routesToRender = []
-  for (const route of pageList) {
-    if (typeof route?.module !== 'string' || !route.module) continue
-    if (!pathIsPrerenderable(route.path)) {
-      reporter?.skipPrerender?.(
-        route.id,
-        `not static (${JSON.stringify(route.path)})`
-      )
-      console.warn(
-        `[@ossy/app][prerender] Skipping "${route.id}" (path not prerenderable: ${JSON.stringify(route.path)})`
-      )
-      continue
-    }
-    routesToRender.push(route)
-  }
-
-  const results = await Promise.allSettled(
-    routesToRender.map(async (route) => {
-      const t0 = Date.now()
-      reporter?.startPrerender?.(route.id)
-      try {
-        await prerenderOnePage({
-          route,
-          buildTimeConfig,
-          pageList,
-          publicDir,
-        })
-        reporter?.completePrerender?.(route.id, { ok: true, ms: Date.now() - t0 })
-      } catch (error) {
-        reporter?.completePrerender?.(route.id, {
-          ok: false,
-          ms: Date.now() - t0,
-          error,
-        })
-        console.error(
-          `[@ossy/app][prerender] "${route?.id}" (${route?.path}) failed:`,
-          error
-        )
-        throw error
-      }
-    })
-  )
-  const failures = countSettledFailures(results)
-
+  const failures = results.filter((r) => r.status === 'rejected').length
   return { results, failures }
 }
 
-async function runProduction ({
-  clientHydrateInput,
-  pageFilesLength,
-  copyPublicFrom,
-  buildPath,
-  nodeEnv,
-  pagesEntryPath,
-  configSourcePath,
-  createClientRollupPlugins,
-  minifyBrowserStaticChunks,
-  reporter,
-}) {
-  if (pageFilesLength === 0 || Object.keys(clientHydrateInput).length === 0) {
-    return { bundleFailures: 0, prerenderFailures: 0 }
-  }
-
-  const { failures: bundleFailures } = await bundleHydratePagesParallel({
-    clientHydrateInput,
-    buildPath,
-    copyPublicFrom,
-    nodeEnv,
-    buildPathForPlugins: buildPath,
-    createClientRollupPlugins,
-    minifyBrowserStaticChunks,
-    reporter,
-  })
-
-  const { failures: prerenderFailures } = await prerenderPagesParallel({
-    pagesEntryPath,
-    configSourcePath,
-    publicDir: path.join(buildPath, 'public'),
-    reporter,
-  })
-
-  if (bundleFailures + prerenderFailures > 0) {
-    console.warn(
-      `[@ossy/app][build] Finished with ${bundleFailures} client bundle error(s) and ${prerenderFailures} prerender error(s)`
-    )
-  }
-
-  return { bundleFailures, prerenderFailures }
-}
-
 export default {
   type: '@ossy/app/prerender-react',
-  /** `input.op`: `runProduction` | `prerenderPagesParallel` (see callers in `build.js` / `dev.js`). */
   async handler (input) {
     const op = input?.op
     if (op === 'runProduction') {
-      return runProduction(input)
-    }
-    if (op === 'prerenderPagesParallel') {
-      return prerenderPagesParallel({
-        pagesEntryPath: input.pagesEntryPath,
-        configSourcePath: input.configSourcePath,
-        publicDir: input.publicDir,
-        reporter: input.reporter,
+      const { clientHydrateInput, pageFilesLength, copyPublicFrom, buildPath, nodeEnv,
+              buildPathForPlugins, createClientRollupPlugins, minifyBrowserStaticChunks, reporter } = input
+      if (pageFilesLength === 0 || Object.keys(clientHydrateInput).length === 0) {
+        return { bundleFailures: 0 }
+      }
+      const { failures: bundleFailures } = await bundleHydratePagesParallel({
+        clientHydrateInput,
+        buildPath,
+        copyPublicFrom,
+        nodeEnv,
+        buildPathForPlugins: buildPathForPlugins ?? buildPath,
+        createClientRollupPlugins,
+        minifyBrowserStaticChunks,
+        reporter,
       })
+      if (bundleFailures > 0) {
+        console.warn(`[@ossy/app][build] Finished with ${bundleFailures} client bundle error(s)`)
+      }
+      return { bundleFailures }
     }
     throw new Error(
-      `[@ossy/app][prerender-react] Unknown op: ${String(op)} (expected runProduction | prerenderPagesParallel)`
+      `[@ossy/app][prerender-react] Unknown op: ${String(op)} (expected runProduction)`
     )
   },
 }

package/cli/render-page.task.js

@@ -1,30 +1,22 @@
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
-import React, { createElement } from 'react'
-import { prerenderToNodeStream } from 'react-dom/static'
 
 const __ossyDir = path.dirname(fileURLToPath(import.meta.url))
 
-async function loadPageDefaultExport (route) {
-  if (typeof route?.module !== 'string' || !route.module) {
-    throw new Error(
-      `[@ossy/app][BuildPage] Route "${route?.id ?? '?'}" has no compiled module path (re-run build so pages.generated.json includes "module").`
-    )
+async function loadSsrBundle (route) {
+  if (typeof route?.id !== 'string' || !route.id) {
+    throw new Error(`[@ossy/app][BuildPage] Route has no id`)
   }
-  const abs = path.join(__ossyDir, route.module)
-  const mod = await import(pathToFileURL(abs).href)
-  const def = mod?.default
-  if (typeof def !== 'function') {
+  const bundlePath = path.join(__ossyDir, '..', 'ssr', `${route.id}.mjs`)
+  const mod = await import(pathToFileURL(bundlePath).href)
+  if (typeof mod?.renderPage !== 'function') {
     throw new Error(
-      `[@ossy/app][BuildPage] Page "${route?.id}" must export default as a function component (got ${typeof def}).`
+      `[@ossy/app][BuildPage] SSR bundle for "${route.id}" must export renderPage (got ${typeof mod?.renderPage}).`
     )
   }
-  return def
+  return mod
 }
 
-/**
- * App shell config for SSR / prerender (mirrors client: theme, pages metadata, props for the active page).
- */
 export function buildPrerenderAppConfig ({
   buildTimeConfig,
   pageList,
@@ -32,11 +24,9 @@ export function buildPrerenderAppConfig ({
   urlPath,
   isAuthenticated = false,
 }) {
-  /** `module` is the lazy import path segment (see `OSSY_PAGE_MODULE_WEB_PREFIX` in the server). */
   const pages = pageList.map((page) => ({
     id: page?.id,
     path: page?.path,
-    ...(typeof page?.module === 'string' ? { module: page.module } : {}),
   }))
   return {
     ...buildTimeConfig,
@@ -50,23 +40,8 @@ export function buildPrerenderAppConfig ({
   }
 }
 
-/** Strips non-JSON content for the bootstrap script; keeps serializable route fields including `module`. */
-export function appConfigForBootstrap (appConfig) {
-  if (!appConfig || typeof appConfig !== 'object') return appConfig
-  const pages = Array.isArray(appConfig.pages)
-    ? appConfig.pages.map(({ id, path, module }) => ({
-        id,
-        path,
-        ...(typeof module === 'string' ? { module } : {}),
-      }))
-    : appConfig.pages
-  return { ...appConfig, pages }
-}
-
-/** Plain data clone so server render props match `JSON.parse(JSON.stringify(...))` on the client. */
 function jsonSafeClone (value) {
   if (value == null || typeof value !== 'object') return value
-  if (typeof value === 'function' || React.isValidElement(value)) return value
   try {
     return JSON.parse(JSON.stringify(value))
   } catch {
@@ -74,42 +49,24 @@ function jsonSafeClone (value) {
   }
 }
 
-/**
- * Props passed to `<App>` for SSR and the exact object embedded in `window.__INITIAL_APP_CONFIG__`.
- * Keeps server and hydrate trees aligned (fixes React #418 hydration mismatches).
- */
 export function buildHydrationAppConfig (appConfig) {
-  const base = appConfigForBootstrap(appConfig)
+  if (!appConfig || typeof appConfig !== 'object') return appConfig
   return {
-    ...base,
-    theme: jsonSafeClone(base.theme),
-    themes: jsonSafeClone(base.themes),
-    resourceTemplates: jsonSafeClone(base.resourceTemplates),
+    ...appConfig,
+    theme: jsonSafeClone(appConfig.theme),
+    themes: jsonSafeClone(appConfig.themes),
+    resourceTemplates: jsonSafeClone(appConfig.resourceTemplates),
   }
 }
 
 export const BuildPage = {
-  async handle ({ route, appConfig, isDevReloadEnabled }) {
+  async handle ({ route, appConfig }) {
     const hydrationConfig = buildHydrationAppConfig(appConfig)
-    const Page = await loadPageDefaultExport(route)
-    const rootElement = createElement(Page, hydrationConfig)
-    const devReloadScript = isDevReloadEnabled
-      ? `(function(){try{var es=new EventSource('/__ossy_reload');es.addEventListener('reload',function(){location.reload();});}catch(e){}})();`
-      : ``
-
-    const hydrateUrl = `/static/${route.id}.js`
-    const { prelude } = await prerenderToNodeStream(rootElement, {
-      bootstrapScriptContent: `window.__INITIAL_APP_CONFIG__ = ${JSON.stringify(hydrationConfig)};${devReloadScript}`,
-      bootstrapModules: [hydrateUrl],
-    })
+    const { renderPage } = await loadSsrBundle(route)
 
-    return new Promise((resolve, reject) => {
-      let data = ''
-      prelude.on('data', (chunk) => {
-        data += chunk
-      })
-      prelude.on('end', () => resolve(data))
-      prelude.on('error', reject)
+    return renderPage(hydrationConfig, {
+      bootstrapScriptContent: `window.__INITIAL_APP_CONFIG__=${JSON.stringify(hydrationConfig)}`,
+      bootstrapModules: [`/static/${route.id}.js`],
     })
   },
 }

package/cli/server.js

@@ -38,10 +38,6 @@ const app = express();
 
 const currentDir = path.dirname(url.fileURLToPath(import.meta.url))
 const ROOT_PATH = path.resolve(currentDir, 'public')
-const OSSY_PAGE_MODULES_STATIC = path.resolve(currentDir, '.ossy', 'page-modules')
-
-const isDevReloadEnabled = process.env.OSSY_DEV_RELOAD === '1'
-const reloadClients = new Set()
 
 function parsePortFromArgv(argv) {
   // Supports: --port 4000, --port=4000, -p 4000
@@ -68,33 +64,6 @@ if (Middleware !== undefined) {
   console.log(`[@ossy/app][server] ${Middleware?.length || 0} custom middleware loaded`)
 }
 
-if (isDevReloadEnabled) {
-  app.get('/__ossy_reload', (req, res) => {
-    res.status(200)
-    res.setHeader('Content-Type', 'text/event-stream')
-    res.setHeader('Cache-Control', 'no-cache')
-    res.setHeader('Connection', 'keep-alive')
-    res.flushHeaders?.()
-
-    res.write('event: connected\ndata: ok\n\n')
-    reloadClients.add(res)
-
-    req.on('close', () => {
-      reloadClients.delete(res)
-    })
-  })
-
-  app.post('/__ossy_reload', (req, res) => {
-    for (const client of reloadClients) {
-      try {
-        client.write('event: reload\ndata: now\n\n')
-      } catch {
-        // ignore broken connections
-      }
-    }
-    res.status(204).end()
-  })
-}
 
 const middleware = [
   morgan('tiny'),
@@ -122,10 +91,6 @@ const middleware = [
   ProxyInternal(),
 ]
 
-const pageModuleRouter = express.Router()
-pageModuleRouter.use(express.static(OSSY_PAGE_MODULES_STATIC))
-app.use('/__ossy/page-modules', pageModuleRouter)
-
 app.use(middleware)
 
 const apiRouter = OssyRouter.of({
@@ -168,11 +133,7 @@ app.all('*all', async (req, res) => {
         urlPath: requestUrl,
         isAuthenticated: !!req.isAuthenticated,
       })
-      const html = await BuildPage.handle({
-        route: pageRoute,
-        appConfig,
-        isDevReloadEnabled,
-      })
+      const html = await BuildPage.handle({ route: pageRoute, appConfig })
       res.status(200).type('html').send(html)
       return
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "1.11.6",
+  "version": "1.11.8",
   "description": "",
   "source": "./src/index.js",
   "main": "./src/index.js",
@@ -27,14 +27,14 @@
     "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-react": "^7.26.3",
     "@babel/register": "^7.25.9",
-    "@ossy/connected-components": "^1.11.6",
-    "@ossy/design-system": "^1.11.6",
-    "@ossy/pages": "^1.11.6",
-    "@ossy/router": "^1.11.6",
-    "@ossy/router-react": "^1.11.6",
-    "@ossy/sdk": "^1.11.6",
-    "@ossy/sdk-react": "^1.11.6",
-    "@ossy/themes": "^1.11.6",
+    "@ossy/connected-components": "^1.11.8",
+    "@ossy/design-system": "^1.11.8",
+    "@ossy/pages": "^1.11.8",
+    "@ossy/router": "^1.11.8",
+    "@ossy/router-react": "^1.11.8",
+    "@ossy/sdk": "^1.11.8",
+    "@ossy/sdk-react": "^1.11.8",
+    "@ossy/themes": "^1.11.8",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -67,5 +67,5 @@
     "README.md",
     "tsconfig.json"
   ],
-  "gitHead": "f9bbe1dbd426b6ee5d07021428b900c570952ea4"
+  "gitHead": "16cef74bf4a2709ec3bf91cb73f2149703086b62"
 }