@forgehive/task 0.2.0 → 0.2.2

package/src/test/add-listener.test.ts

@@ -1,28 +1,31 @@
-import { Task, type TaskRecord } from '../index'
-import { Schema, type InferSchema } from '@forgehive/schema'
-
-describe('Listener tests', () => {
-  it('Should record one item', async () => {
-    const tape: TaskRecord<{ value: number }, { value: number }>[] = []
-    const task = new Task(function (_argv: { value: number }) {
-      return _argv
+import { Task, type ExecutionRecord } from '../index'
+
+describe('Add listener', () => {
+  it('Should add a listener to the task', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = new Task(async (argv: { value: number }) => {
+      return { value: argv.value }
     })
 
     task.addListener((record) => {
       tape.push(record)
     })
 
-    await task.run({ value: 5 })
-
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toEqual({ value: 5 })
+    await task.run({ value: 1 })
+    expect(tape).toEqual([{
+      input: { value: 1 },
+      output: { value: 1 },
+      boundaries: {},
+      taskName: undefined,
+      metadata: {},
+      type: 'success'
+    }])
   })
 
-  it('Should record execution error', async () => {
-    const tape: TaskRecord<{ value: number }, never>[] = []
-    const task = new Task(function (_argv: { value: number }) {
-      throw new Error('This should happen')
+  it('Should add a listener to the task and catch error', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = new Task(async (_argv: { value: number }) => {
+      throw new Error('Test error')
     })
 
     task.addListener((record) => {
@@ -30,83 +33,106 @@ describe('Listener tests', () => {
     })
 
     try {
-      await task.run({ value: 5 })
-    } catch (e) {
-      // Error is expected
+      await task.run({ value: 1 })
+    } catch (error) {
+      // Expected error
     }
 
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].error).toBe('This should happen')
+    expect(tape).toEqual([{
+      input: { value: 1 },
+      error: 'Test error',
+      boundaries: {},
+      taskName: undefined,
+      metadata: {},
+      type: 'error'
+    }])
   })
 
-  it('Should record validation error', async () => {
-    const tape: TaskRecord<{ value: number | null }, { value: number }>[] = []
-    const schema = new Schema({
-      value: Schema.number().min(5)
-    })
-
-    const task = new Task(function (_argv: InferSchema<typeof schema>) {
-      return _argv
-    }, {
-      schema
+  it('Should add a listener to the task and catch error with null input', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = new Task(async (argv: { value: number | null }) => {
+      if (argv.value === null) {
+        throw new Error('Value is null')
+      }
+      return { value: argv.value }
     })
 
-    task.addListener<{ value: number | null }, { value: number }>((record) => {
+    task.addListener((record) => {
       tape.push(record)
     })
 
     try {
-      await task.run({ value: 3 })
-    } catch (e) {
-      // Error is expected
+      await task.run({ value: null })
+    } catch (error) {
+      // Expected error
     }
 
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 3 })
-    expect(tape[0].error).toContain('Invalid input on:')
-    expect(tape[0].error).toContain('value:')
-    expect(tape[0].error).toContain('Number must be greater than or equal to 5')
+    expect(tape).toEqual([{
+      input: { value: null },
+      error: 'Value is null',
+      boundaries: {},
+      taskName: undefined,
+      metadata: {},
+      type: 'error'
+    }])
   })
 
-  it('Should record multiple records', async () => {
-    const tape: TaskRecord<{ value: number }, { value: number }>[] = []
-    const task = new Task(function (_argv: { value: number }) {
-      return _argv
+  it('Should add a listener to the task and call twice', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = new Task(async (argv: { value: number }) => {
+      return { value: argv.value }
     })
 
     task.addListener((record) => {
       tape.push(record)
     })
 
-    await task.run({ value: 5 })
-    await task.run({ value: 6 })
-
-    expect(tape.length).toBe(2)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toEqual({ value: 5 })
-
-    expect(tape[1].input).toEqual({ value: 6 })
-    expect(tape[1].output).toEqual({ value: 6 })
+    await task.run({ value: 1 })
+    await task.run({ value: 2 })
+
+    expect(tape).toEqual([
+      {
+        input: { value: 1 },
+        output: { value: 1 },
+        boundaries: {},
+        taskName: undefined,
+        metadata: {},
+        type: 'success'
+      },
+      {
+        input: { value: 2 },
+        output: { value: 2 },
+        boundaries: {},
+        taskName: undefined,
+        metadata: {},
+        type: 'success'
+      }
+    ])
   })
 
-  it('Should stop recording', async () => {
-    const tape: TaskRecord<{ value: number }, { value: number }>[] = []
-    const task = new Task(function (_argv: { value: number }) {
-      return _argv
+  it('Should add a listener and remove it', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = new Task(async (argv: { value: number }) => {
+      return { value: argv.value }
     })
 
     task.addListener((record) => {
       tape.push(record)
     })
 
-    await task.run({ value: 5 })
+    await task.run({ value: 1 })
 
     task.removeListener()
-    await task.run({ value: 6 })
 
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toEqual({ value: 5 })
+    await task.run({ value: 2 })
+
+    expect(tape).toEqual([{
+      input: { value: 1 },
+      output: { value: 1 },
+      boundaries: {},
+      taskName: undefined,
+      metadata: {},
+      type: 'success'
+    }])
   })
 })

package/src/test/execution-record-boundaries.test.ts

@@ -0,0 +1,266 @@
+import { createTask, Schema } from '../index'
+
+describe('execution-record-boundaries', () => {
+  describe('setMetadata boundary', () => {
+    it('should add metadata to execution record when setMetadata is called', async () => {
+      // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that uses setMetadata
+      const task = createTask({
+        name: 'metadata-test-task',
+        schema,
+        boundaries: {
+          multiply: async (value: number) => value * 2
+        },
+        fn: async ({ value }, { multiply, setMetadata }) => {
+          await setMetadata('userId', '12345')
+          await setMetadata('executionType', 'background')
+
+          const result = await multiply(value)
+          return { result }
+        }
+      })
+
+      // Run the task with safeRun
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+
+      // Verify the metadata is included in the record
+      expect(record.metadata).toEqual({
+        userId: '12345',
+        executionType: 'background'
+      })
+
+      // Verify the task name and other fields are correct
+      expect(record.taskName).toBe('metadata-test-task')
+      expect(record.input).toEqual({ value: 5 })
+      expect(record.output).toEqual({ result: 10 })
+      expect(record.type).toBe('success')
+    })
+
+    it('should not include setMetadata calls in boundary logs', async () => {
+      // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that uses setMetadata and other boundaries
+      const task = createTask({
+        name: 'boundary-log-test',
+        schema,
+        boundaries: {
+          multiply: async (value: number) => value * 2,
+          fetchData: async (data: string) => `fetched-${data}`
+        },
+        fn: async ({ value }, { multiply, fetchData, setMetadata }) => {
+          await setMetadata('step', 'start')
+
+          const multiplied = await multiply(value)
+          await setMetadata('step', 'multiplied')
+
+          const fetched = await fetchData('test')
+          await setMetadata('step', 'completed')
+
+          return { multiplied, fetched }
+        }
+      })
+
+      // Run the task with safeRun
+      const [result, error, record] = await task.safeRun({ value: 3 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ multiplied: 6, fetched: 'fetched-test' })
+
+      // Verify the metadata is updated to the final value
+      expect(record.metadata).toEqual({
+        step: 'completed'
+      })
+
+      // Verify that only the actual boundaries appear in the logs
+      expect(record.boundaries).toHaveProperty('multiply')
+      expect(record.boundaries).toHaveProperty('fetchData')
+      expect(record.boundaries).not.toHaveProperty('setMetadata')
+
+      // Verify the boundary logs contain the expected calls
+      expect(record.boundaries.multiply).toHaveLength(1)
+      expect(record.boundaries.multiply[0]).toEqual({
+        input: [3],
+        output: 6
+      })
+
+      expect(record.boundaries.fetchData).toHaveLength(1)
+      expect(record.boundaries.fetchData[0]).toEqual({
+        input: ['test'],
+        output: 'fetched-test'
+      })
+    })
+
+    it('should preserve metadata in error scenarios', async () => {
+      // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that sets metadata before throwing an error
+      const task = createTask({
+        name: 'error-metadata-test',
+        schema,
+        boundaries: {},
+        fn: async ({ value }, { setMetadata }) => {
+          await setMetadata('errorContext', 'validation')
+          await setMetadata('userId', '67890')
+
+          if (value < 0) {
+            throw new Error('Value cannot be negative')
+          }
+
+          return { result: value }
+        }
+      })
+
+      // Run the task with a value that will cause an error
+      const [result, error, record] = await task.safeRun({ value: -1 })
+
+      // Verify the execution failed as expected
+      expect(result).toBeNull()
+      expect(error).not.toBeNull()
+      expect(error?.message).toBe('Value cannot be negative')
+
+      // Verify the metadata is preserved in the error record
+      expect(record.metadata).toEqual({
+        errorContext: 'validation',
+        userId: '67890'
+      })
+
+      // Verify other record fields
+      expect(record.taskName).toBe('error-metadata-test')
+      expect(record.input).toEqual({ value: -1 })
+      expect(record.error).toBe('Value cannot be negative')
+      expect(record.type).toBe('error')
+    })
+
+    it('should preserve existing metadata when adding new metadata', async () => {
+      // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that uses setMetadata
+      const task = createTask({
+        name: 'preserve-metadata-test',
+        schema,
+        boundaries: {},
+        fn: async ({ value }, { setMetadata }) => {
+          await setMetadata('step1', 'completed')
+          await setMetadata('step2', 'in-progress')
+          await setMetadata('step1', 'updated') // Overwrite step1
+
+          return { result: value * 2 }
+        }
+      })
+
+      // Run the task with initial metadata context
+      const [result, error, record] = await task.safeRun({ value: 4 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 8 })
+
+      // Verify the metadata contains the final values
+      expect(record.metadata).toEqual({
+        step1: 'updated',
+        step2: 'in-progress'
+      })
+    })
+
+    it('should work with setMetadata in safeReplay', async () => {
+      // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Use a counter to ensure different values between original and replay
+      let executionCounter = 0
+
+      // Create a task with boundaries and metadata
+      const task = createTask({
+        name: 'replay-metadata-test',
+        schema,
+        boundaries: {
+          fetchData: async (value: number) => value * 3
+        },
+        fn: async ({ value }, { fetchData, setMetadata }) => {
+          executionCounter++
+          await setMetadata('replayTest', 'true')
+          await setMetadata('executionNumber', executionCounter.toString())
+
+          const result = await fetchData(value)
+          return { result }
+        }
+      })
+
+      // First, run the task normally to get an execution record
+      const [, , originalRecord] = await task.safeRun({ value: 2 })
+
+      // Verify original metadata was set
+      expect(originalRecord.metadata).toHaveProperty('replayTest', 'true')
+      expect(originalRecord.metadata).toHaveProperty('executionNumber', '1')
+
+      // Now replay the task
+      const [replayResult, replayError, replayRecord] = await task.safeReplay(
+        originalRecord,
+        { boundaries: { fetchData: 'replay' } }
+      )
+
+      // Verify the replay was successful
+      expect(replayError).toBeNull()
+      expect(replayResult).toEqual({ result: 6 })
+
+      // Verify that the replay has its own metadata (setMetadata was called again)
+      expect(replayRecord.metadata).toHaveProperty('replayTest', 'true')
+      expect(replayRecord.metadata).toHaveProperty('executionNumber', '2')
+
+      // The execution numbers should be different since setMetadata was called again
+      expect(replayRecord.metadata?.executionNumber).not.toBe(originalRecord.metadata?.executionNumber)
+      expect(originalRecord.metadata?.executionNumber).toBe('1')
+      expect(replayRecord.metadata?.executionNumber).toBe('2')
+    })
+
+    it('should handle empty metadata gracefully', async () => {
+      // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that doesn't use setMetadata
+      const task = createTask({
+        name: 'no-metadata-test',
+        schema,
+        boundaries: {
+          multiply: async (value: number) => value * 2
+        },
+        fn: async ({ value }, { multiply }) => {
+          const result = await multiply(value)
+          return { result }
+        }
+      })
+
+      // Run the task without using setMetadata
+      const [result, error, record] = await task.safeRun({ value: 7 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 14 })
+
+      // Verify the metadata is empty but defined
+      expect(record.metadata).toEqual({})
+    })
+  })
+})

package/src/test/task-with-boundaries.test.ts

@@ -1,4 +1,4 @@
-import { createTask, Schema, TaskRecord, BoundaryTapeData } from '../index'
+import { createTask, Schema, ExecutionRecord, BoundaryTapeData } from '../index'
 
 // Need to add proxy cache mode to the boundaries
 describe('Boundaries tasks tests', () => {
@@ -148,7 +148,7 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Use the correct type definition for records
-    const records: TaskRecord<{value: number}, Promise<number>>[] = []
+    const records: ExecutionRecord[] = []
 
     // Create a schema for the task that accepts a number
     const schema = new Schema({
@@ -192,7 +192,7 @@ describe('Boundaries tasks tests', () => {
     expect(records.length).toBe(3)
 
     // Sort records by input value for consistent testing
-    const sortedRecords = [...records].sort((a, b) => a.input.value - b.input.value)
+    const sortedRecords = [...records].sort((a, b) => (a.input as {value: number}).value - (b.input as {value: number}).value)
 
     // Check record for first task (value: 2)
     expect(sortedRecords[0].input).toEqual({ value: 2 })