@ossy/platform 1.14.1 → 1.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -16,14 +16,15 @@
     "./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/connected-components": "^1.15.2",
+    "@ossy/router": "^1.15.2",
+    "@ossy/sdk": "^1.15.2",
     "cookie-parser": "^1.4.7",
     "express": ">=5.0.0 <6.0.0",
     "morgan": ">=1.10.1 <2.0.0",
@@ -33,5 +34,5 @@
   "files": [
     "src"
   ],
-  "gitHead": "6476ba57e0bdf65f55dfd6671a59c7a7ad773327"
+  "gitHead": "6a15f3ac4cafdb190beed11e4a93adc0ba28c245"
 }

package/src/getPlatformFiles.task.js

@@ -0,0 +1,50 @@
+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/server.js

@@ -1,59 +1,142 @@
 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'
+import getPlatformFiles, {
+  PAGE_FILE_PATTERN,
+  API_FILE_PATTERN,
+} from './getPlatformFiles.task.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
+
+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
+}
+
+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
 }
 
-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
+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)
+    }
   }
+
+  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 || {}
 }
 
-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.
+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 []
 }
 
-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))
+}
+
+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')
+  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 [config, userMiddleware, routes] = await Promise.all([
+    loadConfig(buildDir),
+    loadMiddleware(buildDir),
+    loadRoutes(buildDir),
+  ])
+
+  const { pages, apis, pageModules, apiModules } = routes
+
+  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 +145,102 @@ 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')
+  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
+        }
+      }
+
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.status(404).send('Not found')
         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,
+
+      const pageRoute = pageRouter.getPageByUrl(requestUrl)
+      if (pageRoute) {
+        const mod = pageModules.get(pageRoute.id)
+        const Component = mod?.default
+        if (typeof Component !== 'function') {
+          res.status(503).type('text').send('SSR runtime unavailable')
+          return
+        }
+        const appConfig = {
+          ...config,
+          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 })),
+          pageId: pageRoute.id,
+          sidebarPrimaryCollapsed: false,
+        }
+        const html = await renderPage({
+          Component,
+          metadata: mod.metadata,
+          appConfig,
+        })
+        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 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 }
+}
+
+export default startServer