@ossy/app 1.16.0 → 1.16.2

package/cli/build.task.js

@@ -46,11 +46,21 @@ function ensureDir (dir) {
   fs.mkdirSync(dir, { recursive: true })
 }
 
-function stubFileNameFor (kind, sourcePath, srcDir) {
+// One source of truth for the per-entry name. Used both as the Rollup
+// `input` key (which becomes the `[name]` token in `entryFileNames`) and
+// as the basename of the generated stub. Flattening the full relative
+// path with `__` keeps two files with the same basename in different
+// folders (e.g. `apps/home.page.jsx` and `analytics/home.page.jsx`) from
+// colliding on the Rollup input map — which the filesystem already
+// guarantees can't happen at the relative-path level.
+function entryNameFromSource (sourcePath, srcDir) {
   const rel = path.relative(srcDir, sourcePath).replace(/\\/g, '/')
-  const flat = rel.replace(/\//g, '__')
+  return rel.replace(/\//g, '__').replace(/\.(jsx?|tsx?|mjs|cjs)$/, '')
+}
+
+function stubFileNameFor (kind, sourcePath, srcDir) {
   const ext = kind === 'page' ? '.entry.jsx' : '.entry.js'
-  return flat.replace(/\.(jsx?|tsx?|mjs|cjs)$/, '') + ext
+  return entryNameFromSource(sourcePath, srcDir) + ext
 }
 
 function relImport (fromAbs, toAbs) {
@@ -147,17 +157,12 @@ export async function build (cliArgs = []) {
   const stubInputMap = {}
 
   for (const entry of allEntries) {
-    const { kind, sourcePath, metadata } = entry
-    const stubFileName = stubFileNameFor(kind, sourcePath, srcDir)
-    const stubAbs = path.join(stubDir, stubFileName)
+    const { kind, sourcePath } = entry
+    const inputName = entryNameFromSource(sourcePath, srcDir)
+    const stubAbs = path.join(stubDir, stubFileNameFor(kind, sourcePath, srcDir))
     fs.writeFileSync(stubAbs, stubFor(kind, { stubAbs, sourceAbs: sourcePath }), 'utf8')
-
-    const inputName = path.basename(sourcePath).replace(/\.(jsx?|tsx?|mjs|cjs)$/, '')
-    if (stubInputMap[inputName]) {
-      throw new Error(`[@ossy/app][build] Duplicate entry name "${inputName}" between ${stubInputMap[inputName]} and ${stubAbs}.`)
-    }
     stubInputMap[inputName] = stubAbs
-    entriesByStub.set(stubAbs, { kind, sourcePath, metadata })
+    entriesByStub.set(stubAbs, { kind, sourcePath })
   }
 
   const configPath = path.resolve(srcDir, 'config.js')
@@ -197,6 +202,8 @@ export async function build (cliArgs = []) {
       }),
       manifestPlugin({
         entriesByStub,
+        srcDir,
+        staticOutDir,
         configValue,
         manifestPath: path.join(buildPath, 'manifest.json'),
       }),

package/cli/get-platform-files.task.js

@@ -1,6 +1,5 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { parse as babelParse } from '@babel/parser'
 
 export const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
 export const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
@@ -10,9 +9,8 @@ export const TASK_FILE_PATTERN = /\.task\.(mjs|cjs|js)$/
  * @typedef {'page' | 'api' | 'task'} EntryKind
  *
  * @typedef {object} PlatformEntry
- * @property {EntryKind} kind         Which bucket this entry lives in.
- * @property {string} sourcePath      Absolute path to the user-authored source file.
- * @property {object} metadata        Normalized metadata (always has `id`; pages always have `path`).
+ * @property {EntryKind} kind     Which bucket this entry lives in.
+ * @property {string} sourcePath  Absolute path to the user-authored source file.
  *
  * @typedef {object} PlatformFiles
  * @property {PlatformEntry[]} pages  Discovered `*.page.{jsx,tsx,...}` entries.
@@ -43,7 +41,14 @@ function classifyFile (absPath) {
   return null
 }
 
-function metadataIdFromFile (absPath, srcDir) {
+/**
+ * Default `id` derived from a source file's location relative to `src/`.
+ * Used when a source module doesn't export `metadata.id`.
+ *   `src/home.page.jsx`            -> `home`
+ *   `src/index.page.jsx`           -> `home`
+ *   `src/blog/post.page.jsx`       -> `blog-post`
+ */
+export function metadataIdFromFile (absPath, srcDir) {
   const rel = path.relative(srcDir, absPath).replace(/\\/g, '/')
   const noExt = rel
     .replace(PAGE_FILE_PATTERN, '')
@@ -53,110 +58,22 @@ function metadataIdFromFile (absPath, srcDir) {
   return noExt.replace(/\//g, '-')
 }
 
-function defaultPageRoute (id) {
+/**
+ * Default URL path for a page when `metadata.path` isn't set.
+ * `home` is a special case — it lives at `/`.
+ */
+export function defaultPageRoute (id) {
   return id === 'home' ? '/' : '/' + id
 }
 
-// Parses the static `metadata` export from a source file without executing it.
-// Returns a plain JS-able shape: strings, numbers, booleans, arrays, and
-// nested objects with string keys. Arbitrary expressions (function calls,
-// references) are not supported here — pages must declare their metadata as
-// a literal object expression so the build can read it without bundling.
-function parseMetadataFromSource (absPath) {
-  const source = fs.readFileSync(absPath, 'utf8')
-  const ext = path.extname(absPath)
-  const plugins = ['importMeta']
-  if (ext === '.tsx' || ext === '.ts') plugins.push('typescript')
-  if (ext === '.jsx' || ext === '.tsx') plugins.push('jsx')
-
-  let ast
-  try {
-    ast = babelParse(source, {
-      sourceType: 'module',
-      allowImportExportEverywhere: true,
-      plugins,
-    })
-  } catch (err) {
-    throw new Error(`[@ossy/app][build] Failed to parse ${absPath}: ${err.message}`)
-  }
-
-  for (const node of ast.program.body) {
-    if (node.type !== 'ExportNamedDeclaration') continue
-    const decl = node.declaration
-    if (!decl || decl.type !== 'VariableDeclaration') continue
-    for (const declarator of decl.declarations) {
-      if (declarator.id?.type !== 'Identifier') continue
-      if (declarator.id.name !== 'metadata') continue
-      const literal = literalFromNode(declarator.init)
-      if (literal === undefined) {
-        throw new Error(`[@ossy/app][build] metadata in ${absPath} must be a literal object expression.`)
-      }
-      return literal
-    }
-  }
-  return null
-}
-
-function literalFromNode (node) {
-  if (!node) return undefined
-  switch (node.type) {
-    case 'StringLiteral':
-    case 'NumericLiteral':
-    case 'BooleanLiteral':
-      return node.value
-    case 'NullLiteral':
-      return null
-    case 'TemplateLiteral':
-      if (node.expressions.length === 0) return node.quasis.map((q) => q.value.cooked).join('')
-      return undefined
-    case 'ArrayExpression': {
-      const out = []
-      for (const el of node.elements) {
-        if (el === null) { out.push(null); continue }
-        const value = literalFromNode(el)
-        if (value === undefined) return undefined
-        out.push(value)
-      }
-      return out
-    }
-    case 'ObjectExpression': {
-      const out = {}
-      for (const prop of node.properties) {
-        if (prop.type !== 'ObjectProperty') return undefined
-        let key
-        if (prop.key.type === 'Identifier') key = prop.key.name
-        else if (prop.key.type === 'StringLiteral') key = prop.key.value
-        else return undefined
-        const value = literalFromNode(prop.value)
-        if (value === undefined) return undefined
-        out[key] = value
-      }
-      return out
-    }
-    default:
-      return undefined
-  }
-}
-
-function ensureMetadataForKind ({ kind, sourcePath, parsed, srcDir }) {
-  const fallbackId = metadataIdFromFile(sourcePath, srcDir)
-  const meta = { ...(parsed || {}) }
-  if (!meta.id) meta.id = fallbackId
-  if (kind === 'page' && meta.path === undefined) meta.path = defaultPageRoute(meta.id)
-  if (kind === 'task' && !meta.id && meta.type) meta.id = meta.type
-  return meta
-}
-
 /**
- * Walks `srcDir` and returns the user-authored entries that the platform
- * cares about, bucketed by kind and with their static metadata already
- * parsed. Empty (zero-byte) source files are skipped — they're treated as
- * placeholders the user is mid-creating.
+ * Walks `srcDir` and returns the user-authored entries the platform cares
+ * about, bucketed by kind. Empty (zero-byte) source files are skipped — we
+ * treat them as placeholders the user is mid-creating.
  *
- * Build is the only thing that calls this today, but it's deliberately a
- * separate task so the gather phase stays inspectable on its own (handy
- * for tooling, dev servers, and tests that want to know "what's in src/?"
- * without triggering Rollup).
+ * Metadata isn't read here on purpose: the build pipeline reads it from the
+ * bundled output instead, which lets users compute `metadata.path` (and
+ * anything else) from imports, config, env vars, etc.
  *
  * @param {string} srcDir Absolute path to the project's `src/` directory.
  * @returns {Promise<PlatformFiles>}
@@ -173,12 +90,9 @@ export default async function getPlatformFiles (srcDir) {
     if (!stat.isFile() || stat.size === 0) continue
     const kind = classifyFile(sourcePath)
     if (!kind) continue
-    const parsed = parseMetadataFromSource(sourcePath)
-    const metadata = ensureMetadataForKind({ kind, sourcePath, parsed, srcDir })
     out[kind === 'page' ? 'pages' : kind === 'api' ? 'apis' : 'tasks'].push({
       kind,
       sourcePath,
-      metadata,
     })
   }
   return out

package/cli/manifest-plugin.js

@@ -1,5 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+import { metadataIdFromFile, defaultPageRoute } from './get-platform-files.task.js'
 
 /**
  * @typedef {import('./get-platform-files.task.js').PlatformEntry} PlatformEntry
@@ -7,9 +10,16 @@ import path from 'node:path'
  * @typedef {object} ManifestPluginOptions
  * @property {Map<string, PlatformEntry>} entriesByStub
  *   Maps each generated stub's absolute path (Rollup's `facadeModuleId`) to
- *   the `PlatformEntry` it was created for. The plugin uses this to recover
- *   the entry's `kind` and parsed metadata after Rollup has bundled and
- *   hashed each chunk.
+ *   the `PlatformEntry` it was created for. Used to recover the entry's
+ *   `kind` and source location after Rollup has bundled and hashed each
+ *   chunk.
+ * @property {string} srcDir
+ *   Absolute path to the project's `src/` — used to derive fallback `id`s
+ *   from source file paths when `metadata.id` is missing.
+ * @property {string} staticOutDir
+ *   Absolute path to Rollup's `output.dir` (typically
+ *   `build/public/static/`). Bundled chunks live here, and we dynamically
+ *   `import()` them to read their exported metadata.
  * @property {object} configValue
  *   The serializable config object (typically `src/config.js`'s default
  *   export). Inlined under `manifest.config` so the platform server doesn't
@@ -44,6 +54,13 @@ import path from 'node:path'
  * top-level key because it isn't an entry — it's the runtime context the
  * platform threads into every page render.
  *
+ * Metadata is read from the **bundled** output, not from the source file.
+ * Each entry stub re-exports `metadata` from the user's module, so once
+ * Rollup writes the chunk we can `await import(chunkUrl)` and read
+ * `mod.metadata` directly. This lets users compute metadata however they
+ * like (function calls, `Object.fromEntries`, values derived from imported
+ * config, etc.) — anything that runs at module load in Node will work.
+ *
  * The plugin runs in the `writeBundle` hook (rather than `generateBundle` +
  * `emitFile`) for two reasons:
  *
@@ -51,22 +68,19 @@ import path from 'node:path'
  *     `output.dir` (`build/public/static/`). Rollup forbids relative paths
  *     in `emitFile({ type: 'asset', fileName })`, so we write the file
  *     directly with `fs` once Rollup has finished writing the chunks.
- *  2. Hashed chunk filenames are only stable in the post-write bundle
- *     object, which is exactly what `writeBundle` is given.
+ *  2. We need the chunks on disk to dynamically `import()` them and read
+ *     their exported `metadata`.
  *
- * For each entry chunk in the bundle whose `facadeModuleId` matches a
- * known stub (see `entriesByStub`), the plugin appends a record to
- * `manifest.entries` and stamps `entry: '/static/<chunk-name>'`.
- * Duplicate ids within a `type` abort the build — routers key on `id`
- * and would otherwise silently dispatch to the wrong entry.
+ * Duplicate ids within a `type` abort the build — routers key on `id` and
+ * would otherwise silently dispatch to the wrong entry.
  *
  * @param {ManifestPluginOptions} options
  * @returns {import('rollup').Plugin}
  */
-export function manifestPlugin ({ entriesByStub, configValue, manifestPath }) {
+export function manifestPlugin ({ entriesByStub, srcDir, staticOutDir, configValue, manifestPath }) {
   return {
     name: 'ossy-manifest',
-    writeBundle (_, bundle) {
+    async writeBundle (_, bundle) {
       /** @type {ManifestEntry[]} */
       const entries = []
       const seenIds = { page: new Set(), api: new Set(), task: new Set() }
@@ -80,8 +94,23 @@ export function manifestPlugin ({ entriesByStub, configValue, manifestPath }) {
         if (!entryInfo) continue
 
         const url = '/static/' + fileName
-        const meta = entryInfo.metadata
-        const id = meta.id
+        const localPath = path.join(staticOutDir, fileName)
+
+        // Cache-bust the import so consecutive builds in a watch loop don't
+        // pick up a stale module from Node's loader cache.
+        const importHref = pathToFileURL(localPath).href + `?ts=${Date.now()}`
+        let mod
+        try {
+          mod = await import(importHref)
+        } catch (err) {
+          this.error(
+            `[@ossy/app][build] Failed to import bundled ${entryInfo.kind} entry ` +
+            `${entryInfo.sourcePath}: ${err && err.message ? err.message : err}`,
+          )
+        }
+
+        const rawMeta = (mod && mod.metadata) || {}
+        const id = rawMeta.id || metadataIdFromFile(entryInfo.sourcePath, srcDir)
         if (!id) {
           this.error(`[@ossy/app][build] ${entryInfo.kind} entry missing metadata.id: ${entryInfo.sourcePath}`)
         }
@@ -91,9 +120,10 @@ export function manifestPlugin ({ entriesByStub, configValue, manifestPath }) {
         seenIds[entryInfo.kind].add(id)
 
         if (entryInfo.kind === 'page') {
-          entries.push({ type: 'page', id, path: meta.path, title: meta.title, entry: url })
+          const pagePath = rawMeta.path !== undefined ? rawMeta.path : defaultPageRoute(id)
+          entries.push({ type: 'page', id, path: pagePath, title: rawMeta.title, entry: url })
         } else if (entryInfo.kind === 'api') {
-          entries.push({ type: 'api', id, path: meta.path, entry: url })
+          entries.push({ type: 'api', id, path: rawMeta.path, entry: url })
         } else {
           entries.push({ type: 'task', id, entry: url })
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/app",
-  "version": "1.16.0",
+  "version": "1.16.2",
   "description": "",
   "source": "./src/index.js",
   "main": "./src/index.js",
@@ -33,15 +33,15 @@
     "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-react": "^7.26.3",
     "@babel/register": "^7.25.9",
-    "@ossy/connected-components": "^1.16.0",
-    "@ossy/design-system": "^1.16.0",
-    "@ossy/pages": "^1.16.0",
-    "@ossy/platform": "^1.15.0",
-    "@ossy/router": "^1.16.0",
-    "@ossy/router-react": "^1.16.0",
-    "@ossy/sdk": "^1.16.0",
-    "@ossy/sdk-react": "^1.16.0",
-    "@ossy/themes": "^1.16.0",
+    "@ossy/connected-components": "^1.16.2",
+    "@ossy/design-system": "^1.16.2",
+    "@ossy/pages": "^1.16.2",
+    "@ossy/platform": "^1.15.2",
+    "@ossy/router": "^1.16.2",
+    "@ossy/router-react": "^1.16.2",
+    "@ossy/sdk": "^1.16.2",
+    "@ossy/sdk-react": "^1.16.2",
+    "@ossy/themes": "^1.16.2",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -75,5 +75,5 @@
     "README.md",
     "tsconfig.json"
   ],
-  "gitHead": "db2ab43d6b3266c59eb53c8046811e0acb3f87f1"
+  "gitHead": "00aca40bd8fcf8510c4a854cb388a780ddb751f7"
 }