@ossy/platform 1.14.0 → 1.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.14.0",
+  "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.0",
-    "@ossy/sdk": "^1.15.0",
+    "@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": "6a7aac8937521487dc9a032a8fe71f02f2a86367"
+  "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,76 +1,142 @@
 import fs from 'node:fs'
-import path from 'path'
-import url from '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'
 
-import buildTimeConfig from './.ossy/server-config.runtime.mjs'
-import { BuildPage, buildPrerenderAppConfig } from './.ossy/render-page.task.js'
-import Middleware from './.ossy/middleware.runtime.js'
+const DEFAULT_PORT = 3000
 
-const __ossyDir = path.dirname(url.fileURLToPath(import.meta.url)) + '/.ossy'
+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
+}
 
-function readOssyJson (name) {
-  return JSON.parse(fs.readFileSync(path.join(__ossyDir, name), 'utf8'))
+async function importModule (absPath) {
+  return import(pathToFileURL(absPath).href)
 }
 
-const apiRouteList = readOssyJson('api.generated.json') ?? []
-const sitePageList = readOssyJson('pages.generated.json') ?? []
-
-function pageRouterLanguageOptions (config, pages) {
-  let supported = config?.supportedLanguages
-  let defaultLanguage = config?.defaultLanguage
-  if ((!supported || supported.length <= 1) && pages.length > 0) {
-    const p0 = pages[0]
-    if (p0 && typeof p0.path === 'object' && p0.path != null) {
-      supported = Object.keys(p0.path)
-      defaultLanguage = defaultLanguage || supported[0]
+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 {
-    supportedLanguages: Array.isArray(supported) ? supported : [],
-    defaultLanguage,
-  }
+
+  return { pages, apis, pageModules, apiModules }
 }
 
-const app = express()
+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 currentDir = path.dirname(url.fileURLToPath(import.meta.url))
-const ROOT_PATH = path.resolve(currentDir, 'public')
+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 []
+}
 
-function parsePortFromArgv (argv) {
-  const idx = argv.findIndex((a) => a === '--port' || a === '-p')
-  if (idx !== -1 && argv[idx + 1]) return argv[idx + 1]
+function cloneSerializable (value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value))
+}
 
-  const eq = argv.find((a) => a.startsWith('--port='))
-  if (eq) return eq.split('=')[1]
+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),
+  }
 
-  return undefined
+  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)
 }
 
-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
-}
+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)
 
-const DEFAULT_PORT = 3000
-const port = normalizePort(parsePortFromArgv(process.argv) ?? process.env.PORT, DEFAULT_PORT)
+  if (!fs.existsSync(buildDir)) {
+    throw new Error(`[@ossy/platform][server] Build directory not found: ${buildDir}. Run \`app build\` first.`)
+  }
 
-if (Middleware !== undefined) {
-  console.log(`[@ossy/platform][server] ${Middleware?.length || 0} custom middleware loaded`)
-}
+  const [config, userMiddleware, routes] = await Promise.all([
+    loadConfig(buildDir),
+    loadMiddleware(buildDir),
+    loadRoutes(buildDir),
+  ])
+
+  const { pages, apis, pageModules, apiModules } = routes
 
-const middleware = [
-  morgan('tiny'),
-  express.json({ strict: false }),
-  cookieParser(process.env.OSSY_COOKIE_SECRET || 'default_secret'),
-  (req, _res, next) => {
+  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')) {
@@ -79,64 +145,102 @@ const middleware = [
     const cookieHeader = req.headers.cookie
     req.isAuthenticated = cookieHeader ? cookieHeader.includes('auth=') : false
     next()
-  },
-  ...(Middleware || []),
-  express.static(ROOT_PATH),
-  ProxyInternal(),
-]
-
-app.use(middleware)
-
-const apiRouter = OssyRouter.of({
-  pages: apiRouteList,
-})
-
-const { supportedLanguages, defaultLanguage } = pageRouterLanguageOptions(
-  buildTimeConfig,
-  sitePageList
-)
-
-const pageRouter = OssyRouter.of({
-  pages: sitePageList,
-  defaultLanguage,
-  supportedLanguages,
-})
-
-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') {
+  })
+  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: 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 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')
-      return
-    }
-    const pageRoute = pageRouter.getPageByUrl(requestUrl)
-    if (pageRoute) {
-      const appConfig = buildPrerenderAppConfig({
-        buildTimeConfig,
-        pageList: sitePageList,
-        activeRouteId: pageRoute.id,
-        urlPath: requestUrl,
-        isAuthenticated: !!req.isAuthenticated,
-      })
-      const html = await BuildPage.handle({ route: pageRoute, appConfig })
-      res.status(200).type('html').send(html)
-      return
+    } catch (err) {
+      console.error('[@ossy/platform][server] Request handling failed:', err)
+      if (!res.headersSent) {
+        res.status(500).type('text').send('Internal Server Error')
+      }
     }
-    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