@forgehive/task 0.1.13 → 0.2.1

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/safe-replay-complex-boundary.test.ts

@@ -1,7 +1,14 @@
 import { Schema } from '@forgehive/schema'
-import { createTask, ExecutionRecord } from '../index'
+import { createTask, ExecutionRecord, getExecutionRecordType } from '../index'
 
 describe('Complex boundary replay 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)
+    }
+  }
   // Define types for our portfolio data
   type Stock = {
     ticker: string;
@@ -81,10 +88,11 @@ describe('Complex boundary replay tests', () => {
     })
 
     // Create the portfolio value calculation task
-    calculatePortfolioValue = createTask(
+    calculatePortfolioValue = createTask({
+      name: 'calculatePortfolioValue',
       schema,
       boundaries,
-      async ({ userId }, { fetchPortfolio, fetchPrice }) => {
+      fn: async ({ userId }, { fetchPortfolio, fetchPrice }) => {
         // First fetch the portfolio for the user
         const portfolio = await fetchPortfolio(userId)
 
@@ -114,7 +122,7 @@ describe('Complex boundary replay tests', () => {
           stocks: stocksWithValue
         }
       }
-    )
+    })
   })
 
   it('Should calculate portfolio value using multiple boundaries', async () => {
@@ -158,7 +166,7 @@ describe('Complex boundary replay tests', () => {
 
   it('Should replay portfolio calculation from an execution log', async () => {
     // First create a portfolio value calculation execution log
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { userId: 'user1' },
       output: {
         id: 'portfolio1',
@@ -200,7 +208,7 @@ describe('Complex boundary replay tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for all boundaries
     const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
@@ -235,7 +243,7 @@ describe('Complex boundary replay tests', () => {
 
   it('Should handle errors during replay', async () => {
     // Create an execution log with an error in one of the price fetches
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { userId: 'user1' },
       error: 'Price data not available for ticker: GOOGL',
       boundaries: {
@@ -268,7 +276,7 @@ describe('Complex boundary replay tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for all boundaries
     const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
@@ -303,7 +311,7 @@ describe('Complex boundary replay tests', () => {
     priceData['AAPL'] = 195.00 // Different from replay data
 
     // Create an execution log with historical data
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { userId: 'user1' },
       output: {
         id: 'portfolio1',
@@ -345,7 +353,7 @@ describe('Complex boundary replay tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for portfolio but proxy mode for prices
     const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(

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)