@ossy/platform 1.14.2 → 1.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.14.2",
+  "version": "1.15.1",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -22,17 +22,15 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/connected-components": "^1.15.2",
-    "@ossy/router": "^1.15.2",
-    "@ossy/sdk": "^1.15.2",
+    "@ossy/router": "^1.16.1",
+    "@ossy/sdk": "^1.16.1",
     "cookie-parser": "^1.4.7",
+    "dotenv": ">=16.0.0 <17.0.0",
     "express": ">=5.0.0 <6.0.0",
-    "morgan": ">=1.10.1 <2.0.0",
-    "react": ">=19.0.0 <20.0.0",
-    "react-dom": ">=19.0.0 <20.0.0"
+    "morgan": ">=1.10.1 <2.0.0"
   },
   "files": [
     "src"
   ],
-  "gitHead": "6a15f3ac4cafdb190beed11e4a93adc0ba28c245"
+  "gitHead": "031e2329e267a3e0cebc2ec0d484fa11b53082d9"
 }

package/src/server.js

@@ -6,12 +6,9 @@ import morgan from 'morgan'
 import { Router as OssyRouter } from '@ossy/router'
 import cookieParser from 'cookie-parser'
 import { ProxyInternal } from './proxy-internal.js'
-import getPlatformFiles, {
-  PAGE_FILE_PATTERN,
-  API_FILE_PATTERN,
-} from './getPlatformFiles.task.js'
 
 const DEFAULT_PORT = 3000
+const MANIFEST_FILE = 'manifest.json'
 
 function parsePortFromArgv (argv) {
   const flagIdx = argv.findIndex((a) => a === '--port' || a === '-p')
@@ -27,92 +24,42 @@ function resolvePort (explicit) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PORT
 }
 
-async function importModule (absPath) {
-  return import(pathToFileURL(absPath).href)
-}
-
-async function loadRoutes (buildDir) {
-  const files = await getPlatformFiles(buildDir)
-  const pages = []
-  const apis = []
-  const pageModules = new Map()
-  const apiModules = new Map()
-
-  for (const file of files) {
-    const basename = path.basename(file)
-    const isPage = PAGE_FILE_PATTERN.test(basename)
-    const isApi = API_FILE_PATTERN.test(basename)
-    if (!isPage && !isApi) continue
-
-    const mod = await importModule(file)
-    const metadata = mod.metadata || {}
-    const id = metadata.id
-    const routePath = metadata.path
-    if (!id || !routePath) continue
-
-    const entry = { id, path: routePath, title: metadata.title }
-    if (isPage) {
-      pages.push(entry)
-      pageModules.set(id, mod)
-    } else {
-      apis.push(entry)
-      apiModules.set(id, mod)
-    }
+function loadManifest (buildDir) {
+  const manifestPath = path.join(buildDir, MANIFEST_FILE)
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`[@ossy/platform][server] Build manifest not found: ${manifestPath}. Run \`app build\` first.`)
+  }
+  const raw = fs.readFileSync(manifestPath, 'utf8')
+  const manifest = JSON.parse(raw)
+  // The manifest is a flat `entries` array discriminated by `type`. Bucket
+  // them once at boot so the per-request hot path stays a simple lookup.
+  const entries = Array.isArray(manifest.entries) ? manifest.entries : []
+  const pages = entries.filter((e) => e.type === 'page')
+  const apis = entries.filter((e) => e.type === 'api')
+  const tasks = entries.filter((e) => e.type === 'task')
+  return {
+    entries,
+    pages,
+    apis,
+    tasks,
+    config: manifest.config || {},
   }
-
-  return { pages, apis, pageModules, apiModules }
 }
 
-async function loadConfig (buildDir) {
-  const configPath = path.resolve(buildDir, 'config.js')
-  if (!fs.existsSync(configPath)) return {}
-  const mod = await importModule(configPath)
-  return mod.default || {}
-}
-
-async function loadMiddleware (buildDir) {
-  const mwPath = path.resolve(buildDir, 'middleware.js')
-  if (!fs.existsSync(mwPath)) return []
-  const mod = await importModule(mwPath)
-  const value = mod.default
-  if (Array.isArray(value)) return value
-  if (typeof value === 'function') return [value]
-  return []
+// `entry` URLs in the manifest are public-relative (`/static/<file>`). Translate
+// them to local file URLs for `import()` while passing absolute URLs (e.g. CDN
+// hosted bundles) through unchanged.
+export function resolveEntryUrl (entryUrl, buildDir) {
+  if (!entryUrl) throw new Error('[@ossy/platform][server] Entry URL missing in manifest entry')
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(entryUrl)) return entryUrl
+  const absolute = path.join(buildDir, 'public', entryUrl.startsWith('/') ? entryUrl.slice(1) : entryUrl)
+  return pathToFileURL(absolute).href
 }
 
 function cloneSerializable (value) {
   return value == null ? value : JSON.parse(JSON.stringify(value))
 }
 
-async function renderPage ({ Component, metadata, appConfig }) {
-  const [{ createElement }, { renderToString }, { App }] = await Promise.all([
-    import('react'),
-    import('react-dom/server'),
-    import('@ossy/connected-components'),
-  ])
-
-  const appProps = {
-    ...appConfig,
-    theme: cloneSerializable(appConfig.theme),
-    themes: cloneSerializable(appConfig.themes),
-    resourceTemplates: cloneSerializable(appConfig.resourceTemplates),
-  }
-
-  const element = createElement(
-    'html',
-    { lang: appProps.htmlLang || appProps.defaultLanguage || 'en' },
-    createElement(
-      'head',
-      null,
-      createElement('meta', { charSet: 'utf-8' }),
-      createElement('title', null, metadata?.title || appProps.documentTitle || ''),
-    ),
-    createElement(App, appProps, createElement(Component, appProps)),
-  )
-
-  return '<!doctype html>' + renderToString(element)
-}
-
 export async function startServer (options = {}) {
   const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd()
   const buildDir = path.resolve(cwd, options.buildDir || 'build')
@@ -123,16 +70,30 @@ export async function startServer (options = {}) {
     throw new Error(`[@ossy/platform][server] Build directory not found: ${buildDir}. Run \`app build\` first.`)
   }
 
-  const [config, userMiddleware, routes] = await Promise.all([
-    loadConfig(buildDir),
-    loadMiddleware(buildDir),
-    loadRoutes(buildDir),
-  ])
+  const manifest = loadManifest(buildDir)
+  const config = manifest.config
 
-  const { pages, apis, pageModules, apiModules } = routes
+  const supportedLanguages = Array.isArray(config.supportedLanguages) ? config.supportedLanguages : []
+  const defaultLanguage = config.defaultLanguage
 
-  const app = express()
+  const pageRouter = OssyRouter.of({
+    pages: manifest.pages,
+    supportedLanguages,
+    defaultLanguage,
+  })
+  const apiRouter = OssyRouter.of({ pages: manifest.apis })
+
+  const moduleCache = new Map()
+  async function loadEntry (entryUrl) {
+    if (moduleCache.has(entryUrl)) return moduleCache.get(entryUrl)
+    const promise = import(resolveEntryUrl(entryUrl, buildDir))
+    moduleCache.set(entryUrl, promise)
+    return promise
+  }
+
+  const userMiddleware = await loadMiddleware(buildDir)
 
+  const app = express()
   app.use(morgan('tiny'))
   app.use(express.json({ strict: false }))
   app.use(cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'))
@@ -150,23 +111,18 @@ export async function startServer (options = {}) {
   if (fs.existsSync(publicDir)) app.use(express.static(publicDir))
   app.use(ProxyInternal())
 
-  const apiRouter = OssyRouter.of({ pages: apis })
-  const pageRouter = OssyRouter.of({
-    pages,
-    supportedLanguages: Array.isArray(config.supportedLanguages) ? config.supportedLanguages : [],
-    defaultLanguage: config.defaultLanguage,
-  })
-
   app.all('*all', async (req, res) => {
     const requestUrl = req.originalUrl || '/'
     try {
       const apiRoute = apiRouter.getPageByUrl(requestUrl)
       if (apiRoute) {
-        const mod = apiModules.get(apiRoute.id)
-        const handler = mod?.default
-        if (typeof handler === 'function') {
-          await handler(req, res)
-          return
+        const apiEntry = manifest.apis.find((a) => a.id === apiRoute.id)
+        if (apiEntry) {
+          const mod = await loadEntry(apiEntry.entry)
+          if (typeof mod.handle === 'function') {
+            await mod.handle(req, res)
+            return
+          }
         }
       }
 
@@ -177,28 +133,28 @@ export async function startServer (options = {}) {
 
       const pageRoute = pageRouter.getPageByUrl(requestUrl)
       if (pageRoute) {
-        const mod = pageModules.get(pageRoute.id)
-        const Component = mod?.default
-        if (typeof Component !== 'function') {
+        const pageEntry = manifest.pages.find((p) => p.id === pageRoute.id)
+        if (!pageEntry) {
+          res.status(404).send('Not found')
+          return
+        }
+        const mod = await loadEntry(pageEntry.entry)
+        if (typeof mod.render !== 'function') {
           res.status(503).type('text').send('SSR runtime unavailable')
           return
         }
-        const appConfig = {
+        const props = {
           ...config,
+          theme: cloneSerializable(config?.theme),
+          themes: cloneSerializable(config?.themes),
+          resourceTemplates: cloneSerializable(config?.resourceTemplates),
           url: requestUrl,
-          theme: config?.theme || 'light',
           isAuthenticated: !!req.isAuthenticated,
-          workspaceId: config?.workspaceId,
-          apiUrl: config?.apiUrl,
-          pages: pages.map((page) => ({ id: page?.id, path: page?.path })),
+          pages: manifest.pages.map((page) => ({ id: page.id, path: page.path })),
           pageId: pageRoute.id,
           sidebarPrimaryCollapsed: false,
         }
-        const html = await renderPage({
-          Component,
-          metadata: mod.metadata,
-          appConfig,
-        })
+        const html = await mod.render(props)
         res.status(200).type('html').send(html)
         return
       }
@@ -239,8 +195,22 @@ export async function startServer (options = {}) {
   process.on('SIGTERM', () => handleShutdown('SIGTERM'))
 
   const lifetime = new Promise(() => {})
-
   return { app, server, port, close: closeServer, lifetime }
 }
 
+async function loadMiddleware (buildDir) {
+  const candidates = [
+    path.resolve(buildDir, 'public', 'static', 'middleware.js'),
+    path.resolve(buildDir, 'middleware.js'),
+  ]
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue
+    const mod = await import(pathToFileURL(candidate).href)
+    const value = mod.default
+    if (Array.isArray(value)) return value
+    if (typeof value === 'function') return [value]
+  }
+  return []
+}
+
 export default startServer

package/src/worker-entry.js

@@ -4,7 +4,14 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { runWorkerScheduler } from './worker-runtime.js'
 
-const __ossyDir = path.dirname(fileURLToPath(import.meta.url)) + '/.ossy'
-const tasks = JSON.parse(fs.readFileSync(path.join(__ossyDir, 'tasks.generated.json'), 'utf8')) ?? []
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const buildDir = process.env.OSSY_BUILD_DIR
+  ? path.resolve(process.env.OSSY_BUILD_DIR)
+  : path.resolve(__dirname, '..', '..', '..', 'build')
+const manifestPath = path.join(buildDir, 'manifest.json')
 
-runWorkerScheduler(tasks, __ossyDir)
+const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+const entries = Array.isArray(manifest.entries) ? manifest.entries : []
+const tasks = entries.filter((e) => e.type === 'task')
+
+runWorkerScheduler(tasks, buildDir)

package/src/worker-runtime.js

@@ -2,11 +2,18 @@ import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { SDK } from '@ossy/sdk'
 
+function resolveTaskEntryUrl (entryUrl, buildDir) {
+  if (!entryUrl) throw new Error('[@ossy/platform][worker] Task entry URL missing')
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(entryUrl)) return entryUrl
+  const trimmed = entryUrl.startsWith('/') ? entryUrl.slice(1) : entryUrl
+  return pathToFileURL(path.join(buildDir, 'public', trimmed)).href
+}
+
 /**
- * @param {Array<{ type: string, module: string }>} tasks
- * @param {string} ossyDir - absolute path to the .ossy directory
+ * @param {Array<{ id: string, entry: string }>} tasks
+ * @param {string} buildDir - absolute path to the build directory
  */
-export function runWorkerScheduler (tasks, ossyDir) {
+export function runWorkerScheduler (tasks, buildDir) {
   const sdk = SDK.of({
     workspaceId: process.env.OSSY_WORKSPACE_ID,
     apiUrl: process.env.OSSY_API_URL,
@@ -92,20 +99,25 @@ export function runWorkerScheduler (tasks, ossyDir) {
     console.log(`Processing ${jobList.length} jobs`)
     for (const job of jobList) {
       console.log(`Processing job ${job.id}`)
-      const task = tasks.find((t) => t.type === job.type)
+      const task = tasks.find((t) => t.id === job.type)
       if (!task) {
         console.log('No handler found for job', job.id)
         continue
       }
 
-      console.log(`Handler found for ${task.type}`)
+      console.log(`Handler found for ${task.id}`)
       try {
-        const mod = await import(pathToFileURL(path.resolve(ossyDir, task.module)).href)
+        const mod = await import(resolveTaskEntryUrl(task.entry, buildDir))
         const jobSdk = SDK.of({
           workspaceId: job.belongsTo,
           authorization: process.env.OSSY_API_TOKEN,
         })
-        await mod.default({ sdk: jobSdk, job }).catch(() => {})
+        const runner = typeof mod.run === 'function' ? mod.run : mod.default
+        if (typeof runner !== 'function') {
+          console.log(`Task ${task.id} has no callable handler`)
+          continue
+        }
+        await runner({ sdk: jobSdk, job }).catch(() => {})
       } catch (error) {
         console.error(error)
         console.log('Failed to processing job')

package/src/getPlatformFiles.task.js

@@ -1,50 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-export const PAGE_FILE_PATTERN = /\.page\.(jsx?|tsx?)$/
-export const API_FILE_PATTERN = /\.api\.(mjs|cjs|js)$/
-export const TASK_FILE_PATTERN = /\.task\.(mjs|cjs|js)$/
-export const RESOURCE_TEMPLATE_FILE_PATTERN = /\.resource\.(mjs|cjs|js)$/
-
-function discoverFilesByPattern (srcDir, filePattern) {
-  const dir = path.resolve(srcDir)
-  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
-    return []
-  }
-  const files = []
-  const walk = (d) => {
-    const entries = fs.readdirSync(d, { withFileTypes: true })
-    for (const e of entries) {
-      const full = path.join(d, e.name)
-      if (e.isDirectory()) walk(full)
-      else if (filePattern.test(e.name)) files.push(full)
-    }
-  }
-  walk(dir)
-  return files
-}
-
-
-export default async function getPlatformFiles(_folder) {
-  const cwd = process.cwd()
-  const folder = path.resolve(cwd, _folder)
-
-  const configPath = fs.existsSync(path.resolve(folder, 'config.js')) ? path.resolve(folder, 'config.js') : null
-  const middlewarePath = fs.existsSync(path.resolve(folder, 'middleware.js')) ? path.resolve(folder, 'middleware.js') : null
-
-  const pageFiles = discoverFilesByPattern(folder, PAGE_FILE_PATTERN)
-  const apiFiles = discoverFilesByPattern(folder, API_FILE_PATTERN)
-  const taskFiles = discoverFilesByPattern(folder, TASK_FILE_PATTERN)
-  const resourceTemplatesFiles = discoverFilesByPattern(folder, TASK_FILE_PATTERN)
-
- const entries = [
-  ...(middlewarePath ? [middlewarePath] : []),
-  ...(configPath ? [configPath] : []),
-  ...pageFiles,
-  ...apiFiles,
-  ...taskFiles,
-  ...resourceTemplatesFiles,
- ]
-
- return entries
-}

package/src/http.js

@@ -1,85 +0,0 @@
-import path from 'path';
-import url from 'url'
-import express from 'express'
-import morgan from 'morgan'
-import { Router as OssyRouter } from '@ossy/router'
-import cookieParser from 'cookie-parser'
-
-const app = express();
-
-const currentDir = path.dirname(url.fileURLToPath(import.meta.url))
-
-function parsePortFromArgv(argv) {
-  // Supports: --port 4000, --port=4000, -p 4000
-  const idx = argv.findIndex(a => a === '--port' || a === '-p')
-  if (idx !== -1 && argv[idx + 1]) return argv[idx + 1]
-
-  const eq = argv.find(a => a.startsWith('--port='))
-  if (eq) return eq.split('=')[1]
-
-  return undefined
-}
-
-function normalizePort(value, fallback) {
-  if (value === undefined || value === null || value === '') return fallback
-  const n = Number.parseInt(String(value), 10)
-  if (!Number.isFinite(n) || n <= 0) return fallback
-  return n
-}
-
-const DEFAULT_PORT = 3000
-const port = normalizePort(parsePortFromArgv(process.argv) ?? process.env.PORT, DEFAULT_PORT)
-
-const middleware = [
-  morgan('tiny'),
-  express.json({ strict: false }),
-  cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'),
-]
-
-app.use(middleware)
-
-// const PageRegistry = OssyRouter.of({ pages: [] })
-// const ApiRegistry = OssyRouter.of({ api: [] })
-// const TaskRegistry = OssyRouter.of({ tasks: [] })
-// const StaticRegistry = OssyRouter.of({ static: [] })
-
-const Registry = OssyRouter.of({ pages: [
-    {
-        id: 'home',
-        type: '@ossy/platform/page',
-        path: '/',
-        content: '<h1>Hello World from page route</h1>'
-    },
-    {
-        id: 'home',
-        type: '@ossy/platform/api',
-        path: '/api',
-        handle: (req, res) => {
-            res.send({ message: 'Hello World from api route' })
-        }
-    }
-]})
-
-app.all('*all', (req, res) => {
-  const pathname = req.originalUrl
-
-  // Will be replaced with fetching the resource from ossy storage
-  const resource = Registry.getPageByUrl(pathname)
-
-  if (resource.type === '@ossy/platform/page') {
-    res.send(resource.content)
-  }
-
-  else if (resource.type === '@ossy/platform/api') {
-    resource.handle(req, res)
-  }
-
-  else {
-    res.status(404).send('Not found')
-  }
-  
-})
-
-app.listen(port, () => {
-  console.log(`[@ossy/app][server] Running on http://localhost:${port}`);
-});