@ossy/platform 1.39.2 → 3.0.1

package/src/tasks/task-service.js

@@ -1,11 +1,21 @@
 import { matchesGlob } from './glob.js'
 import { matchesCron } from './cron.js'
 import { IntegrationService } from '../integration.service.js'
-import { createLogger, metrics } from '@ossy/observability'
+import { createLogger } from '@ossy/observability'
+import { isPrimaryTaskForAction, taskIdFromActionId } from '@ossy/schema'
+import { TaskRunService } from '../audit/task-run-service.js'
 
 const SCHEDULER_INTERVAL_MS = 60_000
 const _serviceLog = createLogger('TaskService')
 
+function buildTaskContext (baseContext, extras = {}) {
+  return {
+    ...baseContext,
+    ...extras,
+    payload: baseContext.payload ?? extras.payload,
+  }
+}
+
 export class TaskService {
 
   static _stopped = false
@@ -80,13 +90,44 @@ export class TaskService {
    * Synchronously invoke a task by id (HTTP / sdk.invoke path).
    *
    * @param {string} id
-   * @param {{ payload?: unknown, sdk?: unknown, log?: unknown, integrations?: unknown, req?: unknown }} context
+   * @param {{ payload?: unknown, sdk?: unknown, log?: unknown, integrations?: unknown, req?: unknown, actionInvocationId?: string }} context
    * @returns {Promise<unknown>}
    */
   static async invoke(id, context = {}) {
     const task = TaskService._tasksById.get(id)
     if (!task) throw new Error(`[TaskService] Task not found: "${id}"`)
-    return task.handler(context)
+
+    const audit = context.audit !== false && task.metadata.audit !== false
+
+    return TaskRunService.execute({
+      taskId: id,
+      handler: task.handler,
+      context,
+      trigger: 'invoke',
+      triggeredBy: {
+        channel: context.req ? undefined : 'api',
+        actionInvocationId: context.actionInvocationId ?? null,
+      },
+      executionEnv: 'ossy_server',
+      audit,
+    })
+  }
+
+  /** @param {string} id */
+  static has (id) {
+    return TaskService._tasksById.has(id)
+  }
+
+  /**
+   * @param {string} actionId
+   * @returns {boolean}
+   */
+  static hasTaskForAction (actionId) {
+    try {
+      return TaskService.has(taskIdFromActionId(actionId))
+    } catch {
+      return false
+    }
   }
 
   /**
@@ -101,23 +142,107 @@ export class TaskService {
 
     for (const { metadata, handler } of TaskService._tasks) {
       const triggers = metadata.triggers ?? []
-      const matched = triggers.some(trigger => TaskService._matchesTrigger(trigger, event))
+      const matched = triggers.some(trigger => TaskService._matchesEventTrigger(trigger, event))
 
       if (!matched) continue
 
       _serviceLog.info(`Dispatching task "${metadata.id}"`)
 
+      const taskContext = buildTaskContext(
+        { sdk: effectiveSdk, integrations: IntegrationService, log: createLogger(metadata.id) },
+        {
+          event,
+          payload: { workspaceId: event.payload?.belongsTo },
+        },
+      )
+
       const _taskId = metadata.id
-      const _start = Date.now()
-      Promise.resolve()
-        .then(() => handler({ event, sdk: effectiveSdk, integrations: IntegrationService, log: createLogger(metadata.id) }))
-        .catch(error =>
-          _serviceLog.error(`Task "${metadata.id}" failed`, undefined, error),
-        )
-        .finally(() => {
-          try { metrics.timing('task.duration', Date.now() - _start, { task: _taskId }) } catch {}
-          try { metrics.increment('task.run', { task: _taskId }) } catch {}
-        })
+      TaskRunService.executeAsync({
+        taskId: _taskId,
+        handler,
+        context: taskContext,
+        trigger: 'on_event',
+        triggeredBy: {
+          eventId: event.id,
+          resourceId: event.resourceId,
+          type: event.type,
+          event: event.event,
+        },
+        executionEnv: 'ossy_server',
+        audit: metadata.audit !== false,
+      })
+    }
+  }
+
+  /**
+   * Dispatches follow-up tasks registered with `on_action` triggers after an action completes.
+   *
+   * @param {{
+   *   actionId: string,
+   *   actionInvocationId?: string,
+   *   payload?: unknown,
+   *   result?: unknown,
+   *   success: boolean,
+   *   error?: Error,
+   *   req?: import('express').Request,
+   *   sdk?: unknown,
+   * }} actionContext
+   */
+  static dispatchOnAction (actionContext) {
+    const {
+      actionId,
+      actionInvocationId,
+      payload,
+      result,
+      success,
+      error,
+      req,
+      sdk,
+    } = actionContext
+
+    for (const { metadata, handler } of TaskService._tasks) {
+      if (isPrimaryTaskForAction(actionId, metadata.id)) continue
+
+      const triggers = metadata.triggers ?? []
+      const matched = triggers.some(trigger => TaskService._matchesActionTrigger(trigger, actionId))
+
+      if (!matched) continue
+
+      _serviceLog.info(`Dispatching on_action task "${metadata.id}" for action "${actionId}"`)
+
+      const taskContext = buildTaskContext(
+        {
+          sdk: sdk ?? TaskService._sdk,
+          integrations: IntegrationService,
+          log: createLogger(metadata.id),
+          req,
+          actionInvocationId,
+          payload,
+        },
+        {
+          action: {
+            id: actionId,
+            success,
+            result,
+            error: error ? { message: error.message } : undefined,
+          },
+        },
+      )
+
+      const _taskId = metadata.id
+      TaskRunService.executeAsync({
+        taskId: _taskId,
+        handler,
+        context: taskContext,
+        trigger: 'on_action',
+        triggeredBy: {
+          actionId,
+          actionInvocationId: actionInvocationId ?? null,
+          success,
+        },
+        executionEnv: 'ossy_server',
+        audit: metadata.audit !== false,
+      })
     }
   }
 
@@ -143,17 +268,23 @@ export class TaskService {
 
         _serviceLog.info(`Schedule fired for task "${metadata.id}"`)
 
+        const taskContext = {
+          event: { type: 'scheduled', taskId: metadata.id },
+          sdk: TaskService._sdk,
+          integrations: IntegrationService,
+          log: createLogger(metadata.id),
+        }
+
         const _taskId = metadata.id
-        const _start = Date.now()
-        Promise.resolve()
-          .then(() => handler({ event: { type: 'scheduled', taskId: metadata.id }, sdk: TaskService._sdk, integrations: IntegrationService, log: createLogger(metadata.id) }))
-          .catch(error =>
-            _serviceLog.error(`Scheduled task "${metadata.id}" failed`, undefined, error),
-          )
-          .finally(() => {
-            try { metrics.timing('task.duration', Date.now() - _start, { task: _taskId }) } catch {}
-            try { metrics.increment('task.run', { task: _taskId }) } catch {}
-          })
+        TaskRunService.executeAsync({
+          taskId: _taskId,
+          handler,
+          context: taskContext,
+          trigger: 'on_schedule',
+          triggeredBy: { schedule: metadata.schedule },
+          executionEnv: 'ossy_server',
+          audit: metadata.audit !== false,
+        })
       }
     }, SCHEDULER_INTERVAL_MS)
   }
@@ -170,19 +301,65 @@ export class TaskService {
   }
 
   /**
-   * Returns true when a trigger descriptor matches the given eventstore document.
+   * Returns true when an `on_action` trigger matches the given action id.
    *
-   * 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
+   * @param {object} trigger
+   * @param {string} actionId
    */
-  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
+  static _matchesActionTrigger (trigger, actionId) {
+    const kind = trigger.trigger ?? trigger.on
+    if (kind !== 'on_action') return false
+
+    const pattern = trigger.action
+    if (!pattern) return false
+
+    return matchesGlob(pattern, actionId)
+  }
+
+  /**
+   * Returns true when an event trigger descriptor matches the given eventstore document.
+   *
+   * ADR 0008: `trigger.type` = schemaId, `trigger.event` = lifecycle/custom name.
+   * Skips `on_action` triggers (handled by {@link TaskService.dispatchOnAction}).
+   */
+  static _matchesEventTrigger (trigger, event) {
+    const kind = trigger.trigger ?? trigger.on
+    if (kind === 'on_action') return false
+
+    if (trigger.excludeTypes?.includes(event.type)) return false
+
+    const hasPositiveFilter = Boolean(
+      trigger.type ||
+      trigger.event ||
+      trigger.match ||
+      trigger.resource ||
+      trigger.location,
+    )
+    if (!hasPositiveFilter && trigger.excludeTypes?.length) return true
+
+    if (trigger.type && trigger.type !== event.type) return false
+    if (trigger.event && trigger.event !== event.event) return false
+
+    if (trigger.match) {
+      for (const [path, pattern] of Object.entries(trigger.match)) {
+        const fullPath = path.startsWith('payload.') ? path : `payload.${path}`
+        const parts = fullPath.split('.')
+        let cur = event
+        for (const part of parts) {
+          if (cur == null || typeof cur !== 'object') { cur = undefined; break }
+          cur = cur[part]
+        }
+        if (!matchesGlob(pattern, cur)) return false
+      }
+    }
+
+    if (trigger.resource?.type) {
+      const mime = event.payload?.content?.ContentType ?? event.type
+      if (!matchesGlob(trigger.resource.type, mime)) return false
+    }
+
     if (trigger.location?.startsWith && !event.payload?.location?.startsWith?.(trigger.location.startsWith)) return false
+
     return true
   }
 

package/src/tasks/task-service.spec.js

@@ -0,0 +1,187 @@
+import { describe, expect, it } from '@jest/globals'
+import { TaskService } from './task-service.js'
+import { TaskRun } from '../audit/task-run.aggregate.js'
+import { ActionInvocation } from '../audit/action-invocation.aggregate.js'
+import { TaskRunListProjection } from '../audit/task-run-list.aggregate.js'
+import { detectChannel } from '../audit/detect-channel.js'
+import { hashPayload, moduleIdFromTaskId } from '../audit/audit-helpers.js'
+import { isPrimaryTaskForAction, taskIdFromActionId } from '@ossy/schema'
+
+describe('TaskService triggers', () => {
+  it('matches on_action triggers with glob patterns', () => {
+    expect(TaskService._matchesActionTrigger(
+      { trigger: 'on_action', action: '@ossy/booking/actions/*' },
+      '@ossy/booking/actions/create',
+    )).toBe(true)
+
+    expect(TaskService._matchesActionTrigger(
+      { trigger: 'on_action', action: '@ossy/booking/actions/*' },
+      '@ossy/users/actions/create',
+    )).toBe(false)
+  })
+
+  it('ignores on_action triggers in event dispatch', () => {
+    const event = {
+      type: '@ossy/booking/schema/booking',
+      event: 'Created',
+      resourceId: 'b1',
+      payload: { belongsTo: 'ws1' },
+    }
+
+    expect(TaskService._matchesEventTrigger(
+      { trigger: 'on_action', action: '@ossy/booking/actions/*' },
+      event,
+    )).toBe(false)
+
+    expect(TaskService._matchesEventTrigger(
+      { type: '@ossy/booking/schema/booking', event: 'Created' },
+      event,
+    )).toBe(true)
+  })
+
+  it('supports excludeTypes to skip platform audit envelopes', () => {
+    const taskRunEvent = {
+      type: '@ossy/platform/schema/task-run',
+      event: 'Started',
+      resourceId: 'run1',
+      payload: { belongsTo: 'ws1' },
+    }
+
+    expect(TaskService._matchesEventTrigger(
+      { excludeTypes: ['@ossy/platform/schema/task-run'] },
+      taskRunEvent,
+    )).toBe(false)
+
+    expect(TaskService._matchesEventTrigger(
+      { excludeTypes: ['@ossy/platform/schema/task-run'] },
+      {
+        type: '@ossy/booking/schema/booking',
+        event: 'Created',
+        resourceId: 'b1',
+        payload: { belongsTo: 'ws1' },
+      },
+    )).toBe(true)
+  })
+
+  it('skips primary derived task in on_action dispatch', () => {
+    expect(isPrimaryTaskForAction('@ossy/booking/actions/create', '@ossy/booking/tasks/create')).toBe(true)
+    expect(isPrimaryTaskForAction('@ossy/booking/actions/create', '@ossy/booking/tasks/send-reminder')).toBe(false)
+  })
+})
+
+describe('capability id derivation', () => {
+  it('derives task id from action id', () => {
+    expect(taskIdFromActionId('@ossy/booking/actions/create')).toBe('@ossy/booking/tasks/create')
+  })
+})
+
+describe('TaskRun entity fold', () => {
+  it('derives status lifecycle from events', () => {
+    const started = {
+      resourceId: 'run1',
+      type: '@ossy/platform/schema/task-run',
+      event: 'Started',
+      created: 1000,
+      payload: {
+        taskId: '@ossy/booking/tasks/create',
+        moduleId: 'booking',
+        trigger: 'invoke',
+        belongsTo: 'ws1',
+        executionEnv: 'ossy_server',
+      },
+    }
+
+    let state = TaskRun.View([started])
+    expect(state.status).toBe('in progress')
+    expect(state.taskId).toBe('@ossy/booking/tasks/create')
+
+    state = TaskRun.View([
+      started,
+      {
+        event: 'Completed',
+        created: 2500,
+        payload: { durationMs: 1500, resultSummary: { kind: 'object', keyCount: 1 } },
+      },
+    ])
+    expect(state.status).toBe('success')
+    expect(state.durationMs).toBe(1500)
+  })
+})
+
+describe('TaskRunList projection', () => {
+  it('lists runs per workspace and updates status', () => {
+    const started = {
+      resourceId: 'run1',
+      type: '@ossy/platform/schema/task-run',
+      event: 'Started',
+      created: 1000,
+      payload: {
+        taskId: '@ossy/media-tasks/tasks/resize',
+        moduleId: 'media-tasks',
+        trigger: 'on_event',
+        belongsTo: 'ws1',
+      },
+    }
+
+    let state = TaskRunListProjection.initialState('ws1')
+    state = TaskRunListProjection.Apply(started, state)
+    expect(state.runs).toHaveLength(1)
+    expect(state.runs[0].status).toBe('in progress')
+
+    state = TaskRunListProjection.Apply({
+      resourceId: 'run1',
+      event: 'Completed',
+      created: 2000,
+      payload: { durationMs: 1000, resultSummary: null },
+    }, state)
+
+    expect(state.runs[0].status).toBe('success')
+    expect(state.runs[0].durationMs).toBe(1000)
+  })
+})
+
+describe('ActionInvocation entity fold', () => {
+  it('records invoke lifecycle', () => {
+    const invoked = {
+      resourceId: 'inv1',
+      type: '@ossy/platform/schema/action-invocation',
+      event: 'Invoked',
+      created: 500,
+      payload: {
+        actionId: '@ossy/booking/actions/create',
+        moduleId: 'booking',
+        channel: 'mcp',
+        payloadHash: 'abc',
+        belongsTo: 'ws1',
+      },
+    }
+
+    let state = ActionInvocation.View([invoked])
+    expect(state.status).toBe('in progress')
+    expect(state.channel).toBe('mcp')
+
+    state = ActionInvocation.View([
+      invoked,
+      { event: 'Completed', created: 700, payload: { durationMs: 200, taskRunId: 'run1' } },
+    ])
+    expect(state.status).toBe('success')
+    expect(state.taskRunId).toBe('run1')
+  })
+})
+
+describe('audit helpers', () => {
+  it('detects channel from request shape', () => {
+    expect(detectChannel({ originalUrl: '/mcp', signedCookies: {} })).toBe('mcp')
+    expect(detectChannel({ signedCookies: { auth: 'token' } })).toBe('web_ui')
+    expect(detectChannel({ get: () => 'Bearer x' })).toBe('api')
+  })
+
+  it('derives module id from task id', () => {
+    expect(moduleIdFromTaskId('@ossy/booking/tasks/create')).toBe('booking')
+  })
+
+  it('hashes payloads deterministically', () => {
+    expect(hashPayload({ a: 1 })).toBe(hashPayload({ a: 1 }))
+    expect(hashPayload({ a: 1 })).not.toBe(hashPayload({ a: 2 }))
+  })
+})

package/src/test/e2e.util.js

@@ -2,25 +2,22 @@ import { MongoClient } from 'mongodb'
 
 const DB_URL = process.env.DB_URL ?? 'mongodb://localhost:27017/'
 const DB_NAME = process.env.DB_NAME ?? 'ossy-local'
+const USER_SCHEMA = '@ossy/users/schema/user'
+const TOKEN_SCHEMA = '@ossy/tokens/schema/token'
+const WORKSPACE_SCHEMA = '@ossy/workspaces/schema/workspace'
+
+export { DB_URL, DB_NAME }
 export const API_URL = process.env.OSSY_API_URL ?? process.env.API_URL ?? 'http://localhost:3001/api/v0'
 export const ACTIONS_URL = API_URL.replace(/\/api\/v0\/?$/, '')
 export const APP_URL = process.env.OSSY_APP_URL ?? process.env.BASE_URL ?? 'http://localhost:3002'
 
-/**
- * Polls MongoDB until a Verification token appears for the given userId,
- * or throws if it doesn't arrive within the timeout.
- *
- * Uses directConnection=true so the driver doesn't follow the replica-set
- * member list (which uses Docker-internal hostnames like "mongodb:27017"
- * even when connecting via localhost port-forwarding).
- */
-async function getVerificationToken(db, userId, timeoutMs = 10000) {
+async function getVerificationToken (db, userId, timeoutMs = 10000) {
   const eventstore = db.collection('eventstore')
   const deadline = Date.now() + timeoutMs
   while (Date.now() < deadline) {
     const event = await eventstore.findOne({
-      aggregateType: 'Token',
-      type: 'Created',
+      type: TOKEN_SCHEMA,
+      event: 'Created',
       'payload.type': 'Verification',
       createdBy: userId,
     }, { sort: { _id: -1 } })
@@ -30,35 +27,27 @@ async function getVerificationToken(db, userId, timeoutMs = 10000) {
   throw new Error(`Verification token for user ${userId} not found within ${timeoutMs}ms`)
 }
 
-/**
- * Polls MongoDB until a SignedUp event for the given email is found.
- */
-async function getUserIdByEmail(db, email, timeoutMs = 10000) {
+async function getUserIdByEmail (db, email, timeoutMs = 10000) {
   const eventstore = db.collection('eventstore')
   const deadline = Date.now() + timeoutMs
   while (Date.now() < deadline) {
     const event = await eventstore.findOne({
-      aggregateType: 'User',
-      type: 'SignedUp',
+      type: USER_SCHEMA,
+      event: 'Created',
       'payload.email': email,
     }, { sort: { _id: -1 } })
-    if (event?.aggregateId) return event.aggregateId
+    if (event?.resourceId) return event.resourceId
     await new Promise(r => setTimeout(r, 200))
   }
-  throw new Error(`SignedUp event for ${email} not found within ${timeoutMs}ms`)
+  throw new Error(`Created user event for ${email} not found within ${timeoutMs}ms`)
 }
 
-/**
- * Polls MongoDB until the workspace aggregate for the given userId appears.
- * Not fatal if it doesn't arrive — tests that rely on workspace state should
- * handle the null return.
- */
-async function waitForWorkspaceAggregate(db, userId, timeoutMs = 15000) {
+async function waitForWorkspaceAggregate (db, userId, timeoutMs = 15000) {
   const aggregates = db.collection('aggregates')
   const deadline = Date.now() + timeoutMs
   while (Date.now() < deadline) {
     const workspace = await aggregates.findOne({
-      type: 'Workspace',
+      type: WORKSPACE_SCHEMA,
       'state.users': userId,
     })
     if (workspace) return workspace
@@ -67,14 +56,7 @@ async function waitForWorkspaceAggregate(db, userId, timeoutMs = 15000) {
   return null
 }
 
-/**
- * Signs up a new user via the API and returns `{ email, userId, token }`.
- *
- * Waits for the workspace aggregate to be built so tests that rely on
- * `useWorkspaces()` for the post-login redirect will find a workspace
- * immediately. Uses a unique email per call to avoid cross-run conflicts.
- */
-export async function signUpAndGetToken(firstName = 'Test', lastName = 'User') {
+export async function signUpAndGetToken (firstName = 'Test', lastName = 'User') {
   const email = `e2e-${Date.now()}@ossy.local`
   const client = new MongoClient(DB_URL, { directConnection: true })
   try {
@@ -84,7 +66,7 @@ export async function signUpAndGetToken(firstName = 'Test', lastName = 'User') {
     const res = await fetch(`${ACTIONS_URL}/actions`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ action: 'authentication/sign-up', payload: { email, firstName, lastName } }),
+      body: JSON.stringify({ action: '@ossy/authentication/actions/sign-up', payload: { email, firstName, lastName } }),
     })
     if (!res.ok) throw new Error(`Sign-up failed with status ${res.status}`)
 
@@ -98,10 +80,7 @@ export async function signUpAndGetToken(firstName = 'Test', lastName = 'User') {
   }
 }
 
-/**
- * Calls the verify-sign-in endpoint and returns the raw Set-Cookie header.
- */
-export async function verifySignIn(token) {
+export async function verifySignIn (token) {
   const res = await fetch(`${API_URL}/users/verify-sign-in?token=${token}`)
   if (!res.ok) throw new Error(`Verify sign-in failed with status ${res.status}`)
   const cookie = res.headers.get('set-cookie')