@forgehive/task 0.1.13 → 0.2.0

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

@@ -17,14 +17,15 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       }
-    )
+    })
 
     task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -58,14 +59,15 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       }
-    )
+    })
 
     task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -109,10 +111,11 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         if (typeof argv.value === 'undefined') {
           throw new Error('Value is required')
@@ -120,7 +123,7 @@ describe('Listener with boundaries tests', () => {
 
         return { ...externalData, ...argv as { value: number } }
       }
-    )
+    })
 
     task.addListener<Record<string, unknown>, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -158,10 +161,11 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         if (typeof argv.value === 'undefined') {
           throw new Error('Value is required')
@@ -169,7 +173,7 @@ describe('Listener with boundaries tests', () => {
 
         return { ...externalData, ...argv as { value: number } }
       }
-    )
+    })
 
     task.addListener<{ value?: number }, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -216,16 +220,17 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         await boundaries.fetchExternalData()
         await boundaries.fetchExternalData()
 
         return { foo: true }
       }
-    )
+    })
 
     task.addListener<{ value: number }, { foo: boolean }>((record) => {
       tape.push(record)
@@ -263,10 +268,11 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         let counter = argv.value
 
         counter = await boundaries.add(counter)
@@ -275,7 +281,7 @@ describe('Listener with boundaries tests', () => {
 
         return counter
       }
-    )
+    })
 
     task.addListener<{ value: number }, number>((record) => {
       tape.push(record)

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)