@forgehive/task 0.1.12 → 0.2.0

package/src/test/safe-replay.test.ts

@@ -1,7 +1,15 @@
 import { Schema } from '@forgehive/schema'
-import { createTask, ExecutionRecord } from '../index'
+import { createTask, ExecutionRecord, getExecutionRecordType } from '../index'
 
 describe('safeReplay functionality tests', () => {
+  // Helper function to create ExecutionRecord with computed type
+  function createExecutionRecord<T, U>(partial: Omit<ExecutionRecord<T, U>, 'type'>): ExecutionRecord<T, U> {
+    return {
+      ...partial,
+      type: getExecutionRecordType(partial)
+    }
+  }
+
   // Common variables
   let prices: Record<string, number>
   let boundaries: {
@@ -38,22 +46,23 @@ describe('safeReplay functionality tests', () => {
     }
 
     // Create the task using createTask
-    getTickerPrice = createTask(
+    getTickerPrice = createTask({
+      name: 'getTickerPrice',
       schema,
       boundaries,
-      async ({ ticker }, { fetchData }) => {
+      fn: async ({ ticker }, { fetchData }) => {
         const price = await fetchData(ticker)
         return {
           ticker,
           price
         }
       }
-    )
+    })
   })
 
   it('Should replay a previous execution using the execution log and replay the fetchData boundary', async () => {
     // Create a manual execution log
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { ticker: 'AAPL' },
       output: {
         ticker: 'AAPL',
@@ -67,7 +76,7 @@ describe('safeReplay functionality tests', () => {
           }
         ]
       }
-    }
+    })
 
     // No safeReplay method yet, this will be implemented later
     // This will be our test for that functionality
@@ -101,7 +110,7 @@ describe('safeReplay functionality tests', () => {
 
   it('Should execute with mixed boundaries modes', async () => {
     // Create a manual execution log for testing
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { ticker: 'AAPL' },
       output: {
         ticker: 'AAPL',
@@ -115,7 +124,7 @@ describe('safeReplay functionality tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use mixed mode - replay for fetchData but execute logAccess
     const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(
@@ -153,7 +162,7 @@ describe('safeReplay functionality tests', () => {
 
   it('Should properly handle errors in boundary replay mode', async () => {
     // Create a manual execution log with an error in the boundary
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { ticker: 'AAPL' },
       output: null,
       error: 'API error: Rate limit exceeded',
@@ -165,7 +174,7 @@ describe('safeReplay functionality tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for fetchData
     const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(
@@ -189,7 +198,7 @@ describe('safeReplay functionality tests', () => {
 
   it('Should handle boundaries with both output and error as null', async () => {
     // Create a manual execution log with null output and error in the boundary
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { ticker: 'AAPL' },
       output: { ticker: 'AAPL', price: 160.23 },
       boundaries: {
@@ -201,7 +210,7 @@ describe('safeReplay functionality tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for fetchData
     const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(

package/src/test/safe-run.test.ts

@@ -15,14 +15,15 @@ describe('Task safeRun tests', () => {
     }
 
     // Create the task
-    const successTask = createTask(
+    const successTask = createTask({
+      name: 'successTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Call safeRun with valid input
     const [result, error, record] = await successTask.safeRun({ value: 5 })
@@ -58,14 +59,15 @@ describe('Task safeRun tests', () => {
     }
 
     // Create the task
-    const errorTask = createTask(
+    const errorTask = createTask({
+      name: 'errorTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Call safeRun with problematic input that will cause an error
     const [result, error, record] = await errorTask.safeRun({ value: -5 })
@@ -101,14 +103,15 @@ describe('Task safeRun tests', () => {
     }
 
     // Create the task
-    const validationTask = createTask(
+    const validationTask = createTask({
+      name: 'validationTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Call safeRun with invalid input that will fail schema validation
     const [result, error, record] = await validationTask.safeRun({ value: 0 })
@@ -142,14 +145,15 @@ describe('Task safeRun tests', () => {
     }
 
     // Create the task
-    const listenerTask = createTask(
+    const listenerTask = createTask({
+      name: 'listenerTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return result
       }
-    )
+    })
 
     // Create a mock listener
     const originalListener = jest.fn()
@@ -206,15 +210,16 @@ describe('Task safeRun tests', () => {
     }
 
     // Create a task that uses multiple boundaries
-    const multiBoundaryTask = createTask(
+    const multiBoundaryTask = createTask({
+      name: 'multiBoundaryTask',
       schema,
       boundaries,
-      async function ({ values }, { doubleValue, sumValues }) {
+      fn: async function ({ values }, { doubleValue, sumValues }) {
         const doubled = await Promise.all(values.map(value => doubleValue(value)))
         const total = await sumValues(doubled)
         return { doubled, total }
       }
-    )
+    })
 
     // Call safeRun
     const [result, error, record] = await multiBoundaryTask.safeRun({ values: [1, 2, 3] })

package/src/test/task-boundary-mocking.test.ts

@@ -17,14 +17,15 @@ describe('Task boundary mocking', () => {
     }
 
     // Create the task using createTask
-    const multiplyTask = createTask(
+    const multiplyTask = createTask({
+      name: 'multiplyTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData }) {
+      fn: async function ({ value }, { fetchExternalData }) {
         const result = value * await fetchExternalData(value)
         return result
       }
-    )
+    })
 
     // Create mock for fetchExternalData boundary that returns a specific value
     const mockFetchData = jest.fn().mockResolvedValue(5)
@@ -71,15 +72,16 @@ describe('Task boundary mocking', () => {
     }
 
     // Create the task
-    const calculateTask = createTask(
+    const calculateTask = createTask({
+      name: 'calculateTask',
       schema,
       boundaries,
-      async function ({ value }, { doubleValue, tripleValue }) {
+      fn: async function ({ value }, { doubleValue, tripleValue }) {
         const doubled = await doubleValue(value)
         const tripled = await tripleValue(value)
         return doubled + tripled
       }
-    )
+    })
 
     // Create wrapped mock functions
     const mockDoubleValue = jest.fn().mockResolvedValue(10)

package/src/test/task-execution-log.test.ts

@@ -0,0 +1,246 @@
+import { createTask, Schema, getExecutionRecordType } from '../index'
+
+describe('Task execution log record', () => {
+  describe('Task name in execution record', () => {
+    it('should include task name in safeRun execution record when task has a name', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task with a name
+      const task = createTask({
+        name: 'test-multiplication-task',
+        description: 'A task that multiplies input by 2',
+        schema,
+        boundaries: {
+          multiply: async (value: number) => value * 2
+        },
+        fn: async ({ value }, { multiply }) => {
+          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 task name is included in the record
+      expect(record.taskName).toBe('test-multiplication-task')
+      expect(record.input).toEqual({ value: 5 })
+      expect(record.output).toEqual({ result: 10 })
+    })
+
+    it('should include undefined task name when task has no name', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task without a name
+      const task = createTask({
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 3 }
+        }
+      })
+
+      // Run the task with safeRun
+      const [result, error, record] = await task.safeRun({ value: 4 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 12 })
+
+      // Verify the task name is undefined in the record
+      expect(record.taskName).toBeUndefined()
+      expect(record.input).toEqual({ value: 4 })
+      expect(record.output).toEqual({ result: 12 })
+    })
+
+    it('should include task name in error execution records', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that will throw an error
+      const task = createTask({
+        name: 'error-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          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 task name is included in the error record
+      expect(record.taskName).toBe('error-task')
+      expect(record.input).toEqual({ value: -1 })
+      expect(record.error).toBe('Value cannot be negative')
+      expect(record.output).toBeUndefined()
+    })
+
+    it('should include task name in safeReplay execution record', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task with boundaries
+      const task = createTask({
+        name: 'replay-test-task',
+        schema,
+        boundaries: {
+          fetchData: async (value: number) => value * 2
+        },
+        fn: async ({ value }, { fetchData }) => {
+          const result = await fetchData(value)
+          return { result }
+        }
+      })
+
+      // First, run the task normally to get an execution record
+      const [, , originalRecord] = await task.safeRun({ value: 3 })
+
+      // 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 the task name is included in the replay record
+      expect(replayRecord.taskName).toBe('replay-test-task')
+      expect(replayRecord.input).toEqual({ value: 3 })
+      expect(replayRecord.output).toEqual({ result: 6 })
+    })
+  })
+
+  describe('Type computation in execution record', () => {
+    it('should have type "success" when task completes successfully', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'success-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 2 }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+      expect(record.type).toBe('success')
+      expect(record.output).toEqual({ result: 10 })
+      expect(record.error).toBeUndefined()
+    })
+
+    it('should have type "error" when task throws an error', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'error-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          if (value < 0) {
+            throw new Error('Value cannot be negative')
+          }
+          return { result: value }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: -1 })
+
+      expect(result).toBeNull()
+      expect(error).not.toBeNull()
+      expect(record.type).toBe('error')
+      expect(record.error).toBe('Value cannot be negative')
+      expect(record.output).toBeUndefined()
+    })
+
+    it('should have type "pending" when neither output nor error is set', async () => {
+      // This tests the getExecutionRecordType utility function directly
+      const partialRecord = {
+        input: { value: 1 },
+        boundaries: {},
+        taskName: 'test'
+      }
+
+      const type = getExecutionRecordType(partialRecord)
+      expect(type).toBe('pending')
+    })
+  })
+
+  describe('Context in execution record', () => {
+    it('should include context when provided to safeRun', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'context-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 2 }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+      expect(record.metadata).toEqual({})
+      expect(record.taskName).toBe('context-task')
+    })
+
+    it('should handle undefined context gracefully', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'no-context-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 2 }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+      expect(record.metadata).toEqual({})
+    })
+  })
+})

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

@@ -14,14 +14,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const indentity = createTask(
+    const indentity = createTask({
+      name: 'indentity',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       }
-    )
+    })
 
     const object = await indentity.run({ bar: true })
     const { foo } = await indentity.run({ foo: true })
@@ -43,22 +44,21 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask with boundariesData
-    const indentity = createTask(
+    const indentity = createTask({
+      name: 'indentity',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       },
-      {
-        boundariesData: {
-          fetchExternalData: [
-            { input: [], output: { foo: false } }
-          ]
-        },
-        mode: 'proxy-pass'
-      }
-    )
+      boundariesData: {
+        fetchExternalData: [
+          { input: [], output: { foo: false } }
+        ]
+      },
+      mode: 'proxy-pass'
+    })
 
     const object = await indentity.run({ bar: true })
     const { foo } = await indentity.run({ foo: true })
@@ -81,14 +81,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const add = createTask(
+    const add = createTask({
+      name: 'add',
       schema,
       boundaries,
-      async function (argv, boundaries) {
+      fn: async function (argv, boundaries) {
         const externalData: number = await boundaries.fetchExternalData(1)
         return argv.value + externalData
       }
-    )
+    })
 
     const six = await add.run({ value: 4 })
     const seven = await add.run({ value: 5 })
@@ -111,22 +112,21 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask with boundariesData
-    const add = createTask(
+    const add = createTask({
+      name: 'add',
       schema,
       boundaries,
-      async function (argv, boundaries) {
+      fn: async function (argv, boundaries) {
         const externalData: number = await boundaries.fetchExternalData(argv.value)
         return argv.value + externalData
       },
-      {
-        boundariesData: {
-          fetchExternalData: [
-            { input: [4], output: 2 }
-          ]
-        },
-        mode: 'proxy-pass'
-      }
-    )
+      boundariesData: {
+        fetchExternalData: [
+          { input: [4], output: 2 }
+        ]
+      },
+      mode: 'proxy-pass'
+    })
 
     const six = await add.run({ value: 4 }) // From tape data
     const fifteen = await add.run({ value: 5 })
@@ -163,14 +163,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const multiplyTask = createTask(
+    const multiplyTask = createTask({
+      name: 'multiplyTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData}) {
+      fn: async function ({ value }, { fetchExternalData}) {
         const externalData: number = await fetchExternalData(value)
         return value * externalData
       }
-    )
+    })
 
     multiplyTask.addListener((record) => {
       records.push(record)
@@ -238,14 +239,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const multiplyTask = createTask(
+    const multiplyTask = createTask({
+      name: 'multiplyTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData }) {
+      fn: async function ({ value }, { fetchExternalData }) {
         const externalData: number = await fetchExternalData(value)
         return value * externalData
       }
-    )
+    })
 
     // Run task with value 2
     await multiplyTask.run({ value: 2 })
@@ -308,18 +310,17 @@ describe('Boundaries tasks tests', () => {
     expect(finalSortedTape[2].output).toBe(8)
 
     // Verify tape can be used for replay in proxy-pass mode
-    const replayTask = createTask(
+    const replayTask = createTask({
+      name: 'replayTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData }) {
+      fn: async function ({ value }, { fetchExternalData }) {
         const externalData: number = await fetchExternalData(value)
         return value * externalData
       },
-      {
-        boundariesData: boundariesData3 as BoundaryTapeData,
-        mode: 'proxy-pass'
-      }
-    )
+      boundariesData: boundariesData3 as BoundaryTapeData,
+      mode: 'proxy-pass'
+    })
 
     // Run task with all three values from the tape
     const result2 = await replayTask.run({ value: 2 })