@forgehive/task 0.1.7 → 0.1.9

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

@@ -0,0 +1,231 @@
+import { Schema } from '@forgehive/schema'
+import { createTask, ExecutionRecord } from '../index'
+
+describe('safeReplay functionality tests', () => {
+  // Common variables
+  let prices: Record<string, number>
+  let boundaries: {
+    fetchData: (ticker: string) => Promise<number>
+  }
+
+  // ToDo: Add correct type for schema and getTickerPrice
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let schema: Schema<Record<string, any>>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let getTickerPrice: any // Using any temporarily until we implement safeReplay
+
+  beforeEach(() => {
+    // Create a schema for the task
+    schema = new Schema({
+      ticker: Schema.string()
+    })
+
+    // Mock price data
+    prices = {
+      'AAPL': 150.23
+    }
+
+    // Define the boundaries
+    boundaries = {
+      fetchData: async (ticker: string): Promise<number> => {
+        // check if the ticker is in the prices object
+        if (!prices[ticker as keyof typeof prices]) {
+          throw new Error(`Ticker ${ticker} not found in prices`)
+        }
+
+        return prices[ticker as keyof typeof prices]
+      }
+    }
+
+    // Create the task using createTask
+    getTickerPrice = createTask(
+      schema,
+      boundaries,
+      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 = {
+      input: { ticker: 'AAPL' },
+      output: {
+        ticker: 'AAPL',
+        price: 160.23
+      },
+      boundaries: {
+        fetchData: [
+          {
+            input: ['AAPL'],
+            output: 160.23
+          }
+        ]
+      }
+    }
+
+    // No safeReplay method yet, this will be implemented later
+    // This will be our test for that functionality
+    const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(
+      executionLog
+    )
+
+    // Verify the replay execution
+    expect(replayError).toBeNull()
+    expect(replayResult).toMatchObject({
+      ticker: 'AAPL',
+      price: 150.23
+    })
+
+    expect(replayLog).toMatchObject({
+      input: { ticker: 'AAPL' },
+      output: {
+        ticker: 'AAPL',
+        price: 150.23
+      },
+      boundaries: {
+        fetchData: [
+          {
+            input: ['AAPL'],
+            output: 150.23,
+          }
+        ]
+      }
+    })
+  })
+
+  it('Should execute with mixed boundaries modes', async () => {
+    // Create a manual execution log for testing
+    const executionLog: ExecutionRecord = {
+      input: { ticker: 'AAPL' },
+      output: {
+        ticker: 'AAPL',
+        price: 160.23
+      },
+      boundaries: {
+        fetchData: [
+          {
+            input: ['AAPL'],
+            output: 160.23
+          }
+        ]
+      }
+    }
+
+    // Use mixed mode - replay for fetchData but execute logAccess
+    const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(
+      executionLog,
+      {
+        boundaries: {
+          fetchData: 'replay',
+        }
+      }
+    )
+
+    // Verify the replay execution
+    expect(replayError).toBeNull()
+    expect(replayResult).toMatchObject({
+      ticker: 'AAPL',
+      price: 160.23
+    })
+
+    expect(replayLog).toMatchObject({
+      input: { ticker: 'AAPL' },
+      output: {
+        ticker: 'AAPL',
+        price: 160.23
+      },
+      boundaries: {
+        fetchData: [
+          {
+            input: ['AAPL'],
+            output: 160.23
+          }
+        ]
+      }
+    })
+  })
+
+  it('Should properly handle errors in boundary replay mode', async () => {
+    // Create a manual execution log with an error in the boundary
+    const executionLog: ExecutionRecord = {
+      input: { ticker: 'AAPL' },
+      output: null,
+      error: 'API error: Rate limit exceeded',
+      boundaries: {
+        fetchData: [
+          {
+            input: ['AAPL'],
+            error: 'API error: Rate limit exceeded'
+          }
+        ]
+      }
+    }
+
+    // Use replay mode for fetchData
+    const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(
+      executionLog,
+      {
+        boundaries: {
+          fetchData: 'replay',
+        }
+      }
+    )
+
+    // Verify the replay execution - should have an error
+    expect(replayResult).toBeNull()
+    expect(replayError).not.toBeNull()
+    expect(replayError?.message).toBe('API error: Rate limit exceeded')
+
+    // The log should contain the error from the boundary
+    expect(replayLog.error).toBeDefined()
+    expect(replayLog.boundaries.fetchData[0].error).toBe('API error: Rate limit exceeded')
+  })
+
+  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 = {
+      input: { ticker: 'AAPL' },
+      output: { ticker: 'AAPL', price: 160.23 },
+      boundaries: {
+        fetchData: [
+          {
+            input: ['AAPL'],
+            output: 160.23,
+            error: null
+          }
+        ]
+      }
+    }
+
+    // Use replay mode for fetchData
+    const [replayResult, replayError, replayLog] = await getTickerPrice.safeReplay(
+      executionLog,
+      {
+        boundaries: {
+          fetchData: 'replay',
+        }
+      }
+    )
+
+    // Verify the replay execution
+    expect(replayError).toBeNull()
+    expect(replayResult).toMatchObject({
+      ticker: 'AAPL',
+      price: 160.23
+    })
+
+    // The log should contain the output from the boundary
+    expect(replayLog.output).toMatchObject({
+      ticker: 'AAPL',
+      price: 160.23
+    })
+    expect(replayLog.boundaries.fetchData[0].output).toBe(160.23)
+    expect(replayLog.boundaries.fetchData[0].error).toBeNull()
+  })
+})

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

@@ -1,4 +1,4 @@
-import { createTask, Schema, TaskRecord } from '../index'
+import { createTask, Schema, TaskRecord, BoundaryTapeData } from '../index'
 
 // Need to add proxy cache mode to the boundaries
 describe('Boundaries tasks tests', () => {
@@ -316,7 +316,7 @@ describe('Boundaries tasks tests', () => {
         return value * externalData
       },
       {
-        boundariesData: boundariesData3,
+        boundariesData: boundariesData3 as BoundaryTapeData,
         mode: 'proxy-pass'
       }
     )

package/src/utils/boundary.ts

@@ -14,17 +14,39 @@ export type Mode = 'proxy' | 'proxy-pass' | 'proxy-catch' | 'replay'
 export type BoundaryFunction<TReturn = any> = (...args: any[]) => Promise<TReturn>
 
 /**
- * Represents a record of a boundary function call
+ * Success record for a boundary function call
  * @template TInput - The type of input data
  * @template TOutput - The type of output data
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface BoundaryRecord<TInput = any[], TOutput = any> {
-  input: TInput
-  output?: TOutput
-  error?: string
+export type BoundarySuccessRecord<TInput = unknown[], TOutput = unknown> = {
+  input: TInput;
+  output: TOutput;
+  error?: null;
 }
 
+/**
+ * Error record for a boundary function call
+ * @template TInput - The type of input data
+ */
+export type BoundaryErrorRecord<TInput = unknown[]> = {
+  input: TInput;
+  output?: null;
+  error: string;
+}
+
+/**
+ * Represents a record of a boundary function call - either success or error
+ * @template TInput - The type of input data
+ * @template TOutput - The type of output data
+ */
+export type BoundaryRecord<TInput = unknown[], TOutput = unknown> =
+  BoundarySuccessRecord<TInput, TOutput> | BoundaryErrorRecord<TInput>;
+
+/**
+ * Represents the tape data for all boundaries
+ */
+export type BoundaryTapeData = Record<string, Array<BoundaryRecord>>;
+
 /**
  * Represents a wrapped boundary function with additional methods
  */
@@ -79,10 +101,6 @@ export const createBoundary = <Func extends BaseBoundary>(fn: Func): WrappedBoun
       return result
     }
 
-    const record: RecordType = {
-      input: args
-    }
-
     if (mode === 'proxy-pass') {
       const record = findRecord(args, cacheTape)
 
@@ -101,7 +119,8 @@ export const createBoundary = <Func extends BaseBoundary>(fn: Func): WrappedBoun
           throw new Error('No tape value for this inputs')
         }
 
-        if (typeof record.error !== 'undefined') {
+        // Check if this is an error record by checking if error property exists
+        if (record.error !== undefined && record.error !== null) {
           throw new Error(record.error)
         }
 
@@ -124,18 +143,26 @@ export const createBoundary = <Func extends BaseBoundary>(fn: Func): WrappedBoun
             return prevRecord.output as unknown as ReturnType<Func>
           })()
         } else {
-          record.error = error.message
+          // Create an error record
+          const errorRecord: BoundaryErrorRecord<FuncInput> = {
+            input: args,
+            error: error.message
+          }
 
-          if (hasRun) { runLog.push(record) }
-          cacheTape.push(record)
+          if (hasRun) { runLog.push(errorRecord) }
+          cacheTape.push(errorRecord)
 
           throw error
         }
       } else {
-        record.output = result as FuncOutput
+        // Create a success record
+        const successRecord: BoundarySuccessRecord<FuncInput, FuncOutput> = {
+          input: args,
+          output: result as FuncOutput
+        }
 
-        if (hasRun) { runLog.push(record) }
-        cacheTape.push(record)
+        if (hasRun) { runLog.push(successRecord) }
+        cacheTape.push(successRecord)
 
         return result as ReturnType<Func>
       }