@ossy/platform 1.39.2 → 1.39.3

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')