@ossy/platform 1.22.4 → 1.22.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "1.22.4",
+  "version": "1.22.6",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -14,8 +14,7 @@
     "./proxy-internal": "./src/proxy-internal.js",
     "./runtime": "./src/runtime.js",
     "./site-loader": "./src/site-loader.js",
-    "./worker": "./src/worker-entry.js",
-    "./worker-runtime": "./src/worker-runtime.js"
+    "./tasks": "./src/index.js"
   },
   "scripts": {
     "start": "PORT=3003 node -e \"import('./src/server.js').then(m => m.startServer())\""
@@ -24,8 +23,8 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/router": "^1.23.4",
-    "@ossy/sdk": "^1.23.4",
+    "@ossy/router": "^1.23.6",
+    "@ossy/sdk": "^1.23.6",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -35,5 +34,5 @@
     "src",
     "Dockerfile"
   ],
-  "gitHead": "f5b2f3495d91b046b7357771ee7b0d3c7f29fcc6"
+  "gitHead": "3454264bf96915a89b08c1855dd36bc54a8e6d26"
 }

package/src/index.js

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

package/src/tasks/cron.js

@@ -0,0 +1,86 @@
+/**
+ * Minimal cron expression matcher for the 5-field standard format:
+ *   minute  hour  day-of-month  month  day-of-week
+ *
+ * Each field supports:
+ *   *        — any value
+ *   n        — exact value
+ *   a-b      — inclusive range
+ *   a,b,c    — comma-separated list (each item may itself be a range or step)
+ *   *\/n      — step from 0 (e.g. *\/5 on minutes = 0,5,10,15,20,25,30,35,40,45,50,55)
+ *   a-b\/n   — step within range
+ */
+
+/**
+ * Parse a single cron field against a numeric value.
+ * @param {string} field - One cron field token.
+ * @param {number} value - Current time component to test.
+ * @param {number} min   - Minimum valid value for this field.
+ * @param {number} max   - Maximum valid value for this field.
+ * @returns {boolean}
+ */
+function matchField(field, value, min, max) {
+  if (field === '*') return true
+
+  for (const part of field.split(',')) {
+    if (matchPart(part.trim(), value, min, max)) return true
+  }
+  return false
+}
+
+function matchPart(part, value, min, max) {
+  // Step: */n or a-b/n
+  if (part.includes('/')) {
+    const [rangePart, stepStr] = part.split('/')
+    const step = parseInt(stepStr, 10)
+    if (isNaN(step) || step <= 0) return false
+
+    const [rangeMin, rangeMax] = rangePart === '*'
+      ? [min, max]
+      : rangePart.includes('-')
+        ? rangePart.split('-').map(Number)
+        : [parseInt(rangePart, 10), max]
+
+    if (value < rangeMin || value > rangeMax) return false
+    return (value - rangeMin) % step === 0
+  }
+
+  // Range: a-b
+  if (part.includes('-')) {
+    const [lo, hi] = part.split('-').map(Number)
+    return value >= lo && value <= hi
+  }
+
+  // Exact
+  return parseInt(part, 10) === value
+}
+
+/**
+ * Returns true when the given cron expression matches the provided Date.
+ *
+ * @param {string} expression - 5-field cron string (e.g. "* /5 * * * *" without the space).
+ * @param {Date}   date       - Date to test against (defaults to now).
+ * @returns {boolean}
+ */
+export function matchesCron(expression, date = new Date()) {
+  if (!expression || typeof expression !== 'string') return false
+
+  const fields = expression.trim().split(/\s+/)
+  if (fields.length !== 5) return false
+
+  const [minuteF, hourF, domF, monthF, dowF] = fields
+
+  const minute = date.getMinutes()       // 0–59
+  const hour   = date.getHours()         // 0–23
+  const dom    = date.getDate()          // 1–31
+  const month  = date.getMonth() + 1     // 1–12
+  const dow    = date.getDay()           // 0–6 (0=Sunday)
+
+  return (
+    matchField(minuteF, minute, 0, 59) &&
+    matchField(hourF,   hour,   0, 23) &&
+    matchField(domF,    dom,    1, 31) &&
+    matchField(monthF,  month,  1, 12) &&
+    matchField(dowF,    dow,    0, 6)
+  )
+}

package/src/tasks/glob.js

@@ -0,0 +1,12 @@
+/**
+ * Glob matcher: ** matches any chars including /, * matches any chars except /.
+ */
+export function matchesGlob(pattern, value) {
+  if (!pattern || value == null) return false
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '§§')   // protect ** before replacing *
+    .replace(/\*/g, '[^/]*')
+    .replace(/§§/g, '.*')
+  return new RegExp(`^${escaped}$`).test(value)
+}

package/src/tasks/task-loader.js

@@ -0,0 +1,75 @@
+import { readdir, readFile } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+
+const TASK_FILE_PATTERN = /\.task\.(mjs|cjs|js)$/
+
+/**
+ * Discover all *.task.js files from:
+ * 1. The cwd's own src/ directory (recursive)
+ * 2. Any node_modules package that has "ossy": { "src": ... } in package.json
+ *
+ * Returns an array of file:// URLs suitable for dynamic import().
+ */
+export async function discoverTaskFiles({ cwd }) {
+  const files = []
+
+  // 1. Walk local src/
+  await walkDir(join(cwd, 'src'), files)
+
+  // 2. Walk node_modules packages with ossy.src
+  const nodeModulesDir = join(cwd, 'node_modules')
+  try {
+    const entries = await readdir(nodeModulesDir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
+
+      // Handle scoped packages (@ossy/...)
+      if (entry.name.startsWith('@')) {
+        const scopedEntries = await readdir(join(nodeModulesDir, entry.name), { withFileTypes: true })
+        for (const scoped of scopedEntries) {
+          const pkgPath = join(nodeModulesDir, entry.name, scoped.name)
+          await checkPackageForTasks(pkgPath, files)
+        }
+        continue
+      }
+
+      const pkgPath = join(nodeModulesDir, entry.name)
+      await checkPackageForTasks(pkgPath, files)
+    }
+  } catch {
+    // node_modules doesn't exist yet
+  }
+
+  return files
+}
+
+async function checkPackageForTasks(pkgPath, files) {
+  try {
+    const pkgJson = JSON.parse(await readFile(join(pkgPath, 'package.json'), 'utf8'))
+    const ossySrc = pkgJson?.ossy?.src
+    if (!ossySrc) return
+    await walkDir(join(pkgPath, ossySrc), files)
+  } catch {
+    // no package.json or not readable
+  }
+}
+
+async function walkDir(dir, files) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const full = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        await walkDir(full, files)
+      } else if (TASK_FILE_PATTERN.test(entry.name)) {
+        files.push(pathToFileUrl(full))
+      }
+    }
+  } catch {
+    // dir doesn't exist
+  }
+}
+
+function pathToFileUrl(filePath) {
+  return new URL('file://' + resolve(filePath)).href
+}

package/src/tasks/task-registry.js

@@ -0,0 +1,17 @@
+import { discoverTaskFiles } from './task-loader.js'
+import { TaskService } from './task-service.js'
+
+export async function loadAndRegisterTasks({ cwd }) {
+  const taskFiles = await discoverTaskFiles({ cwd })
+
+  for (const fileUrl of taskFiles) {
+    try {
+      const taskModule = await import(fileUrl)
+      if (taskModule.metadata) {
+        TaskService.registerTask(taskModule)
+      }
+    } catch (err) {
+      console.error(`[TaskService] Failed to load task ${fileUrl}:`, err.message)
+    }
+  }
+}

package/src/tasks/task-service.js

@@ -0,0 +1,124 @@
+import { matchesGlob } from './glob.js'
+import { matchesCron } from './cron.js'
+
+const SCHEDULER_INTERVAL_MS = 60_000
+
+export class TaskService {
+
+  static _stopped = false
+
+  /** @type {Array<{ metadata: object, handler: function }>} */
+  static _tasks = []
+
+  /** @type {ReturnType<typeof setInterval> | null} */
+  static _schedulerInterval = null
+
+  /**
+   * Register a task module to be dispatched on matching events
+   * and/or on a cron schedule.
+   * @param {{ metadata: { id: string, triggers?: Array, schedule?: string }, default: function }} taskModule
+   */
+  static registerTask(taskModule) {
+    const handler = taskModule.default
+    const metadata = taskModule.metadata
+
+    if (typeof handler !== 'function') {
+      console.error(`[TaskService] Task "${metadata?.id}" has no default export function — skipping`)
+      return
+    }
+    if (!metadata?.id) {
+      console.error('[TaskService] Task has no metadata.id — skipping')
+      return
+    }
+
+    TaskService._tasks.push({ metadata, handler })
+    console.log(
+      `[TaskService] Registered task "${metadata.id}" with ${metadata.triggers?.length ?? 0} trigger(s)` +
+      (metadata.schedule ? ` and schedule "${metadata.schedule}"` : ''),
+    )
+  }
+
+  /**
+   * Dispatches a single event (fullDocument from the changestream) to all
+   * registered tasks whose triggers match.
+   * @param {object} event - The eventstore fullDocument.
+   */
+  static dispatch(event) {
+    if (!event) return
+
+    for (const { metadata, handler } of TaskService._tasks) {
+      const triggers = metadata.triggers ?? []
+      const matched = triggers.some(trigger => TaskService._matchesTrigger(trigger, event))
+
+      if (!matched) continue
+
+      console.log(`[TaskService] Dispatching task "${metadata.id}"`)
+
+      Promise.resolve()
+        .then(() => handler({ event, sdk: null }))
+        .catch(error =>
+          console.error(`[TaskService] Task "${metadata.id}" failed`, error),
+        )
+    }
+  }
+
+  /**
+   * Starts a 60-second interval that fires each scheduled task whose cron
+   * expression matches the current minute.  Calls the handler directly
+   * (no synthetic MongoDB events).
+   */
+  static startScheduler() {
+    const scheduledTasks = TaskService._tasks.filter(t => !!t.metadata.schedule)
+    if (scheduledTasks.length === 0) return
+
+    console.log(`[TaskService] Scheduler started for ${scheduledTasks.length} task(s)`)
+
+    TaskService._stopped = false
+    TaskService._schedulerInterval = setInterval(() => {
+      if (TaskService._stopped) return
+
+      const now = new Date()
+
+      for (const { metadata, handler } of scheduledTasks) {
+        if (!matchesCron(metadata.schedule, now)) continue
+
+        console.log(`[TaskService] Schedule fired for task "${metadata.id}"`)
+
+        Promise.resolve()
+          .then(() => handler({ event: { type: 'scheduled', taskId: metadata.id }, sdk: null }))
+          .catch(error =>
+            console.error(`[TaskService] Scheduled task "${metadata.id}" failed`, error),
+          )
+      }
+    }, SCHEDULER_INTERVAL_MS)
+  }
+
+  /**
+   * Clears the scheduler interval.
+   */
+  static stop() {
+    TaskService._stopped = true
+    if (TaskService._schedulerInterval !== null) {
+      clearInterval(TaskService._schedulerInterval)
+      TaskService._schedulerInterval = null
+    }
+  }
+
+  /**
+   * Returns true when a trigger descriptor matches the given eventstore document.
+   *
+   * Matching rules:
+   *   trigger.aggregateType          — exact match against event.aggregateType
+   *   trigger.event                  — exact match against event.type
+   *   trigger.resource.type          — glob match (supports *) against event.payload.type
+   *   trigger.location.startsWith    — prefix match against event.payload.location
+   */
+  static _matchesTrigger(trigger, event) {
+    if (trigger.aggregateType && trigger.aggregateType !== event.aggregateType) return false
+    if (trigger.event && trigger.event !== event.type) return false
+    if (trigger.resource?.type && !matchesGlob(trigger.resource.type, event.payload?.type)) return false
+    if (trigger.location?.startsWith && !event.payload?.location?.startsWith?.(trigger.location.startsWith)) return false
+    return true
+  }
+
+}

package/src/worker-entry.js

@@ -1,17 +0,0 @@
-import 'dotenv/config'
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { runWorkerScheduler } from './worker-runtime.js'
-
-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')
-
-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

@@ -1,127 +0,0 @@
-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<{ id: string, entry: string }>} tasks
- * @param {string} buildDir - absolute path to the build directory
- */
-export function runWorkerScheduler (tasks, buildDir) {
-  const sdk = SDK.of({
-    workspaceId: process.env.OSSY_WORKSPACE_ID,
-    apiUrl: process.env.OSSY_API_URL,
-    authorization: process.env.OSSY_API_TOKEN,
-  })
-
-  const jobsClient = /** @type {{ getUnprocessed: () => Promise<unknown[]> }} */ (sdk.jobs)
-  let status = 'running'
-
-  console.log('Starting scheduler')
-  main()
-
-  setInterval(() => {
-    if (status === 'running') return
-    status = 'running'
-    try {
-      main()
-    } catch (error) {
-      console.log('Error running main')
-      console.error(error)
-      status = 'idle'
-    }
-  }, 3000)
-
-  function main () {
-    console.log('Looking for jobs')
-    jobsClient
-      .getUnprocessed()
-      .then(async (jobs) => {
-        if (!jobs || !jobs.length) {
-          console.log('No jobs found, going idle')
-          status = 'idle'
-          return
-        }
-
-        const jobsGroupedByResourceId = groupJobsByResourceId(jobs)
-        console.log(`Found ${jobs.length} jobs between ${jobsGroupedByResourceId.length} resources`)
-
-        const processedGroups = jobsGroupedByResourceId.map(([resourceId, groupJobs]) => {
-          console.log(`Processing group for resourceId ${resourceId}`)
-          return processJobsSequentially(groupJobs)
-            .then(() => console.log(`Completed group for resourceId ${resourceId}`))
-            .catch((err) => {
-              console.log(`Failed to process group for resourceId ${resourceId}`)
-              console.error(err)
-            })
-        })
-
-        try {
-          await Promise.allSettled(processedGroups)
-          console.log('Finished processing of groups...')
-          console.log('Going idle')
-          status = 'idle'
-          console.log('----------------------------------')
-          console.groupEnd()
-        } catch (error) {
-          console.log('Error processing groups')
-          console.error(error)
-          status = 'idle'
-        }
-      })
-      .catch((error) => {
-        console.log('Error getting jobs')
-        console.error(error)
-        status = 'idle'
-      })
-  }
-
-  function groupJobsByResourceId (jobList) {
-    return Object.entries(
-      jobList.reduce((acc, job) => {
-        const content = /** @type {{ resourceId?: string }} */ (job.content || {})
-        const rid = content.resourceId
-        return {
-          ...acc,
-          [rid]: [...(acc[rid] || []), job],
-        }
-      }, /** @type {Record<string, unknown[]>} */ ({}))
-    )
-  }
-
-  async function processJobsSequentially (jobList) {
-    console.log(`Processing ${jobList.length} jobs`)
-    for (const job of jobList) {
-      console.log(`Processing job ${job.id}`)
-      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.id}`)
-      try {
-        const mod = await import(resolveTaskEntryUrl(task.entry, buildDir))
-        const jobSdk = SDK.of({
-          workspaceId: job.belongsTo,
-          authorization: process.env.OSSY_API_TOKEN,
-        })
-        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')
-      }
-    }
-  }
-}