@ossy/platform 1.14.1 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.14.1",
+  "version": "1.15.0",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -16,22 +16,21 @@
     "./worker-runtime": "./src/worker-runtime.js"
   },
   "scripts": {
-    "start": "PORT=3003 node ./src/server.js"
+    "start": "PORT=3003 node -e \"import('./src/server.js').then(m => m.startServer())\""
   },
   "keywords": [],
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/router": "^1.15.1",
-    "@ossy/sdk": "^1.15.1",
+    "@ossy/router": "^1.16.0",
+    "@ossy/sdk": "^1.16.0",
     "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": "6476ba57e0bdf65f55dfd6671a59c7a7ad773327"
+  "gitHead": "db2ab43d6b3266c59eb53c8046811e0acb3f87f1"
 }

package/src/server.js

@@ -1,59 +1,103 @@
 import fs from 'node:fs'
-import path from 'path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 import express from 'express'
 import morgan from 'morgan'
 import { Router as OssyRouter } from '@ossy/router'
 import cookieParser from 'cookie-parser'
 import { ProxyInternal } from './proxy-internal.js'
 
-const currentDir = path.dirname(fileURLToPath(import.meta.url))
-const ossyDir = path.join(currentDir, '.ossy')
-const readJson = (name, fallback) => {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(ossyDir, name), 'utf8'))
-  } catch {
-    return fallback
-  }
+const DEFAULT_PORT = 3000
+const MANIFEST_FILE = 'manifest.json'
+
+function parsePortFromArgv (argv) {
+  const flagIdx = argv.findIndex((a) => a === '--port' || a === '-p')
+  if (flagIdx !== -1 && argv[flagIdx + 1]) return argv[flagIdx + 1]
+  const eq = argv.find((a) => a.startsWith('--port='))
+  if (eq) return eq.split('=')[1]
+  return undefined
 }
 
-const loadDefaultFromRef = async (runtimeRefJson) => {
-  const modulePath = readJson(runtimeRefJson, null)?.modulePath
-  if (!modulePath || typeof modulePath !== 'string') return undefined
-  try {
-    const mod = await import(pathToFileURL(path.resolve(modulePath)).href)
-    return mod?.default
-  } catch {
-    return undefined
+function resolvePort (explicit) {
+  const raw = explicit ?? parsePortFromArgv(process.argv) ?? process.env.PORT
+  const parsed = Number.parseInt(String(raw ?? ''), 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PORT
+}
+
+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 || {},
   }
 }
 
-const apiRouteList = readJson('api.generated.json', [])
-const sitePageList = readJson('pages.generated.json', [])
-const buildTimeConfig = (await loadDefaultFromRef('server-config.runtime.json')) || {}
-const Middleware = (await loadDefaultFromRef('middleware.runtime.json')) || []
-let ssrRender = null
-try {
-  ssrRender = (await import(pathToFileURL(path.resolve(currentDir, 'ssr', 'app.mjs')).href)).renderPage
-} catch {
-  // SSR is optional at startup; page requests return 503 when unavailable.
+// `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
 }
 
-const app = express()
-const ROOT_PATH = path.resolve(currentDir, 'public')
-const explicitPortArgIdx = process.argv.findIndex((a) => a === '--port' || a === '-p')
-const explicitPortArg =
-  explicitPortArgIdx !== -1
-    ? process.argv[explicitPortArgIdx + 1]
-    : process.argv.find((a) => a.startsWith('--port='))?.split('=')[1]
-const parsedPort = Number.parseInt(String(explicitPortArg ?? process.env.PORT ?? '3000'), 10)
-const port = Number.isFinite(parsedPort) && parsedPort > 0 ? parsedPort : 3000
-
-const middleware = [
-  morgan('tiny'),
-  express.json({ strict: false }),
-  cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'),
-  (req, _res, next) => {
+function cloneSerializable (value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value))
+}
+
+export async function startServer (options = {}) {
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd()
+  const buildDir = path.resolve(cwd, options.buildDir || 'build')
+  const publicDir = path.resolve(buildDir, 'public')
+  const port = resolvePort(options.port)
+
+  if (!fs.existsSync(buildDir)) {
+    throw new Error(`[@ossy/platform][server] Build directory not found: ${buildDir}. Run \`app build\` first.`)
+  }
+
+  const manifest = loadManifest(buildDir)
+  const config = manifest.config
+
+  const supportedLanguages = Array.isArray(config.supportedLanguages) ? config.supportedLanguages : []
+  const defaultLanguage = config.defaultLanguage
+
+  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'))
+  app.use((req, _res, next) => {
     const userSettings = JSON.parse(req.signedCookies?.['x-ossy-user-settings'] || '{}')
     req.userAppSettings = userSettings
     if (userSettings.workspaceId && !req.get('workspaceId')) {
@@ -62,82 +106,111 @@ const middleware = [
     const cookieHeader = req.headers.cookie
     req.isAuthenticated = cookieHeader ? cookieHeader.includes('auth=') : false
     next()
-  },
-  ...(Array.isArray(Middleware) ? Middleware : []),
-  express.static(ROOT_PATH),
-  ProxyInternal(),
-]
-
-app.use(middleware)
-
-let supportedLanguages = buildTimeConfig?.supportedLanguages
-let defaultLanguage = buildTimeConfig?.defaultLanguage
-if ((!supportedLanguages || supportedLanguages.length <= 1) && sitePageList.length > 0) {
-  const firstPage = sitePageList[0]
-  if (firstPage && typeof firstPage.path === 'object' && firstPage.path != null) {
-    supportedLanguages = Object.keys(firstPage.path)
-    defaultLanguage = defaultLanguage || supportedLanguages[0]
-  }
-}
+  })
+  for (const mw of userMiddleware) app.use(mw)
+  if (fs.existsSync(publicDir)) app.use(express.static(publicDir))
+  app.use(ProxyInternal())
 
-const apiRouter = OssyRouter.of({ pages: apiRouteList })
-const pageRouter = OssyRouter.of({
-  pages: sitePageList,
-  supportedLanguages: Array.isArray(supportedLanguages) ? supportedLanguages : [],
-  defaultLanguage,
-})
-
-app.all('*all', async (req, res) => {
-  const requestUrl = req.originalUrl || '/'
-  try {
-    const apiRoute = apiRouter.getPageByUrl(requestUrl)
-    if (apiRoute?.module) {
-      const mod = await import(pathToFileURL(path.resolve(ossyDir, apiRoute.module)).href)
-      await mod.default(req, res)
-      return
-    }
-    if (req.method !== 'GET' && req.method !== 'HEAD') {
-      res.status(404).send('Not found')
-      return
-    }
-    const pageRoute = pageRouter.getPageByUrl(requestUrl)
-    if (pageRoute) {
-      if (typeof ssrRender !== 'function') {
-        res.status(503).type('text').send('SSR runtime unavailable')
+  app.all('*all', async (req, res) => {
+    const requestUrl = req.originalUrl || '/'
+    try {
+      const apiRoute = apiRouter.getPageByUrl(requestUrl)
+      if (apiRoute) {
+        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
+          }
+        }
+      }
+
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.status(404).send('Not found')
+        return
+      }
+
+      const pageRoute = pageRouter.getPageByUrl(requestUrl)
+      if (pageRoute) {
+        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 props = {
+          ...config,
+          theme: cloneSerializable(config?.theme),
+          themes: cloneSerializable(config?.themes),
+          resourceTemplates: cloneSerializable(config?.resourceTemplates),
+          url: requestUrl,
+          isAuthenticated: !!req.isAuthenticated,
+          pages: manifest.pages.map((page) => ({ id: page.id, path: page.path })),
+          pageId: pageRoute.id,
+          sidebarPrimaryCollapsed: false,
+        }
+        const html = await mod.render(props)
+        res.status(200).type('html').send(html)
         return
       }
-      const appConfig = {
-        ...buildTimeConfig,
-        url: requestUrl,
-        theme: buildTimeConfig?.theme || 'light',
-        isAuthenticated: !!req.isAuthenticated,
-        workspaceId: buildTimeConfig?.workspaceId,
-        apiUrl: buildTimeConfig?.apiUrl,
-        pages: sitePageList.map((page) => ({ id: page?.id, path: page?.path })),
-        pageId: pageRoute.id,
-        sidebarPrimaryCollapsed: false,
+
+      res.status(404).send('Not found')
+    } catch (err) {
+      console.error('[@ossy/platform][server] Request handling failed:', err)
+      if (!res.headersSent) {
+        res.status(500).type('text').send('Internal Server Error')
       }
-      const html = await ssrRender(pageRoute.id, {
-        ...appConfig,
-        theme: appConfig?.theme == null ? appConfig?.theme : JSON.parse(JSON.stringify(appConfig.theme)),
-        themes: appConfig?.themes == null ? appConfig?.themes : JSON.parse(JSON.stringify(appConfig.themes)),
-        resourceTemplates:
-          appConfig?.resourceTemplates == null
-            ? appConfig?.resourceTemplates
-            : JSON.parse(JSON.stringify(appConfig.resourceTemplates)),
-      }, {})
-      res.status(200).type('html').send(html)
-      return
     }
-    res.status(404).send('Not found')
-  } catch (err) {
-    console.error('[@ossy/platform][server] Request handling failed:', err)
-    if (!res.headersSent) {
-      res.status(500).type('text').send('Internal Server Error')
+  })
+
+  const server = await new Promise((resolve, reject) => {
+    const httpServer = app.listen(port)
+    httpServer.once('listening', () => resolve(httpServer))
+    httpServer.once('error', reject)
+  })
+
+  console.log(`[@ossy/platform][server] Running on http://localhost:${port}`)
+  console.log('[@ossy/platform][server] Press Ctrl+C to stop.')
+
+  const closeServer = () => new Promise((resolve) => server.close(() => resolve()))
+
+  let shuttingDown = false
+  const handleShutdown = async (signal) => {
+    if (shuttingDown) return
+    shuttingDown = true
+    console.log(`\n[@ossy/platform][server] Received ${signal}, shutting down...`)
+    try {
+      await closeServer()
+    } finally {
+      process.exit(0)
     }
   }
-})
 
-app.listen(port, () => {
-  console.log(`[@ossy/platform][server] Running on http://localhost:${port}`)
-})
+  process.on('SIGINT', () => handleShutdown('SIGINT'))
+  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/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}`);
-});