@ossy/platform 1.23.1 → 1.24.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.23.1",
+  "version": "1.24.1",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -23,16 +23,17 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/router": "^1.24.1",
-    "@ossy/sdk": "^1.24.1",
+    "@ossy/router": "^1.25.1",
+    "@ossy/sdk": "^1.25.1",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
+    "mongodb": "^7.2.0",
     "morgan": ">=1.10.1 <2.0.0"
   },
   "files": [
     "src",
     "Dockerfile"
   ],
-  "gitHead": "c4dfd4a2cc4a6977ce00dc223c91dbaecc3348ba"
+  "gitHead": "c8a5e5af59c1975ea8e0c5a974202c6c146236c3"
 }

package/src/index.js

@@ -1,2 +1,3 @@
 export { TaskService } from './tasks/task-service.js'
 export { loadAndRegisterTasks } from './tasks/task-registry.js'
+export { ChangeStream } from './tasks/change-stream.js'

package/src/server.js

@@ -6,6 +6,8 @@ import morgan from 'morgan'
 import { Router as OssyRouter } from '@ossy/router'
 import cookieParser from 'cookie-parser'
 import { ProxyInternal } from './proxy-internal.js'
+import { TaskService } from './tasks/task-service.js'
+import { ChangeStream } from './tasks/change-stream.js'
 
 const DEFAULT_PORT = 3000
 const MANIFEST_FILE = 'manifest.json'
@@ -42,6 +44,8 @@ export function loadManifest (buildDir) {
   const pages = entries.filter((e) => e.type === 'page' && validRoutable(e))
   const apis = entries.filter((e) => e.type === 'api' && validRoutable(e))
   const tasks = entries.filter((e) => e.type === 'task')
+  const components = Array.isArray(manifest.components) ? manifest.components : []
+  const resourceTemplates = Array.isArray(manifest.resourceTemplates) ? manifest.resourceTemplates : []
   for (const e of entries) {
     if ((e.type === 'page' || e.type === 'api') && !validRoutable(e)) {
       console.warn(`[@ossy/platform][server] Skipping ${e.type} "${e.id}" — manifest entry has no path.`)
@@ -52,6 +56,8 @@ export function loadManifest (buildDir) {
     pages,
     apis,
     tasks,
+    components,
+    resourceTemplates,
     config: manifest.config || {},
   }
 }
@@ -83,6 +89,22 @@ export async function startServer (options = {}) {
   const manifest = loadManifest(buildDir)
   const config = manifest.config
 
+  for (const task of manifest.tasks ?? []) {
+    try {
+      const mod = await import(resolveEntryUrl(task.entry, buildDir))
+      if (mod.metadata) {
+        TaskService.registerTask(mod)
+      }
+    } catch (err) {
+      console.error(`[@ossy/platform][server] Failed to load task "${task.id}":`, err.message)
+    }
+  }
+  TaskService.startScheduler()
+
+  if (process.env.DB_URL) {
+    ChangeStream.start(process.env.DB_URL)
+  }
+
   const supportedLanguages = Array.isArray(config.supportedLanguages) ? config.supportedLanguages : []
   const defaultLanguage = config.defaultLanguage
 
@@ -158,11 +180,12 @@ export async function startServer (options = {}) {
           ...(req.userAppSettings || {}),
           theme: req.userAppSettings?.theme || cloneSerializable(config?.theme),
           themes: cloneSerializable(config?.themes),
-          resourceTemplates: cloneSerializable(config?.resourceTemplates),
+          resourceTemplates: cloneSerializable(manifest.resourceTemplates),
           url: requestUrl,
           isAuthenticated: !!req.isAuthenticated,
           pages: manifest.pages.map((page) => ({ id: page.id, path: page.path })),
           pageId: pageRoute.id,
+          componentEntries: manifest.components,
         }
         const html = await mod.render(props)
         res.status(200).type('html').send(html)

package/src/tasks/change-stream.js

@@ -0,0 +1,134 @@
+import { TaskService } from './task-service.js'
+
+function isMongoTopologyClosedError(error) {
+  if (!error || typeof error !== 'object') return false
+  if (error.name === 'MongoTopologyClosedError') return true
+  if (typeof error.message === 'string' && error.message.includes('Topology is closed')) return true
+  return false
+}
+
+export class ChangeStream {
+
+  static _stopped = false
+  static _reconnectAttempts = 0
+  static _dbUrl = null
+  static _client = null
+
+  /**
+   * Opens the MongoDB changestream and wires up reconnect logic.
+   * Logs errors; does not crash the process on Mongo outages.
+   * @param {string} dbUrl - MongoDB connection URL (process.env.DB_URL)
+   */
+  static start(dbUrl) {
+    ChangeStream._stopped = false
+    ChangeStream._reconnectAttempts = 0
+    ChangeStream._dbUrl = dbUrl
+    ChangeStream._open().catch((error) => {
+      console.error('[ChangeStream] Change stream could not be opened', error)
+      ChangeStream._scheduleReconnect()
+    })
+  }
+
+  static stop() {
+    ChangeStream._stopped = true
+    if (ChangeStream._client) {
+      ChangeStream._client.close().catch(() => {})
+      ChangeStream._client = null
+    }
+  }
+
+  static async _getMongoClient() {
+    const { MongoClient } = await import('mongodb')
+    return MongoClient
+  }
+
+  static async _getClient() {
+    if (!ChangeStream._client) {
+      const MongoClient = await ChangeStream._getMongoClient()
+      ChangeStream._client = new MongoClient(ChangeStream._dbUrl, {
+        serverSelectionTimeoutMS: 30_000,
+      })
+    }
+    return ChangeStream._client
+  }
+
+  static async _resetClient() {
+    const MongoClient = await ChangeStream._getMongoClient()
+    const prev = ChangeStream._client
+    ChangeStream._client = new MongoClient(ChangeStream._dbUrl, {
+      serverSelectionTimeoutMS: 30_000,
+    })
+    if (prev) {
+      prev.close().catch(() => {})
+    }
+    console.log('[ChangeStream] New MongoClient instance created')
+  }
+
+  static _scheduleReconnect() {
+    if (ChangeStream._stopped) return
+
+    const delaySecs = Math.min(Math.pow(2, ChangeStream._reconnectAttempts), 30)
+    ChangeStream._reconnectAttempts++
+
+    console.log(`[ChangeStream] Reconnecting in ${delaySecs}s...`)
+
+    setTimeout(() => {
+      if (ChangeStream._stopped) return
+      ChangeStream._open().catch((error) => {
+        console.error('[ChangeStream] Change stream could not be opened', error)
+        ChangeStream._scheduleReconnect()
+      })
+    }, delaySecs * 1000)
+  }
+
+  static async _open() {
+    console.log('[ChangeStream] Watching for changes')
+
+    const dbName = process.env.DB_NAME || 'test'
+    const client = await ChangeStream._getClient()
+    const collection = client.db(dbName).collection('eventstore')
+
+    const changeStream = collection.watch([
+      { $match: { operationType: 'insert' } },
+    ])
+
+    const wasReconnecting = ChangeStream._reconnectAttempts > 0
+    ChangeStream._reconnectAttempts = 0
+    if (wasReconnecting) {
+      console.log('[ChangeStream] Reconnected.')
+    }
+
+    // Ensures only one reconnect is scheduled if both 'error' and 'close' fire for the same failure.
+    let reconnectScheduled = false
+    const scheduleOnce = () => {
+      if (!reconnectScheduled) {
+        reconnectScheduled = true
+        ChangeStream._scheduleReconnect()
+      }
+    }
+
+    changeStream.on('error', (error) => {
+      console.error('[ChangeStream] Change stream error (server keeps running)', error)
+      if (isMongoTopologyClosedError(error)) {
+        ChangeStream._resetClient().catch(() => {})
+      }
+      scheduleOnce()
+    })
+
+    changeStream.on('change', (change) => {
+      console.log('[ChangeStream] Change detected')
+      TaskService.dispatch(change.fullDocument)
+    })
+
+    changeStream.on('close', () => {
+      console.log('[ChangeStream] close detected')
+      scheduleOnce()
+    })
+
+    changeStream.on('end', () => {
+      console.log('[ChangeStream] end detected')
+      scheduleOnce()
+    })
+  }
+
+}

package/src/tasks/task-service.js

@@ -19,11 +19,11 @@ export class TaskService {
    * @param {{ metadata: { id: string, triggers?: Array, schedule?: string }, default: function }} taskModule
    */
   static registerTask(taskModule) {
-    const handler = taskModule.default
+    const handler = taskModule.run
     const metadata = taskModule.metadata
 
     if (typeof handler !== 'function') {
-      console.error(`[TaskService] Task "${metadata?.id}" has no default export function — skipping`)
+      console.error(`[TaskService] Task "${metadata?.id}" has no exported "run" function — skipping`)
       return
     }
     if (!metadata?.id) {