@forgehive/task 0.1.7 → 0.1.8

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

@@ -0,0 +1,385 @@
+import { Schema } from '@forgehive/schema'
+import { createTask, ExecutionRecord } from '../index'
+
+describe('Complex boundary replay tests', () => {
+  // Define types for our portfolio data
+  type Stock = {
+    ticker: string;
+    quantity: number;
+  }
+
+  type Portfolio = {
+    id: string;
+    userId: string;
+    stocks: Stock[];
+  }
+
+  // Test data
+  let priceData: Record<string, number>
+  let portfolioData: Record<string, Portfolio>
+
+  // Boundaries for the portfolio task
+  let boundaries: {
+    fetchPrice: (ticker: string) => Promise<number>;
+    fetchPortfolio: (userId: string) => Promise<Portfolio>;
+  }
+
+  // The task - using eslint-disable to allow any type for this test
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let calculatePortfolioValue: any
+
+  beforeEach(() => {
+    // Setup mock data
+    priceData = {
+      'AAPL': 182.63,
+      'MSFT': 421.90,
+      'GOOGL': 171.04,
+      'AMZN': 184.72
+    }
+
+    portfolioData = {
+      'user1': {
+        id: 'portfolio1',
+        userId: 'user1',
+        stocks: [
+          { ticker: 'AAPL', quantity: 10 },
+          { ticker: 'MSFT', quantity: 5 },
+          { ticker: 'GOOGL', quantity: 8 }
+        ]
+      },
+      'user2': {
+        id: 'portfolio2',
+        userId: 'user2',
+        stocks: [
+          { ticker: 'AMZN', quantity: 15 },
+          { ticker: 'MSFT', quantity: 3 }
+        ]
+      }
+    }
+
+    // Define boundaries with realistic functions
+    boundaries = {
+      fetchPrice: async (ticker: string): Promise<number> => {
+        // Check if we have a price for this ticker
+        if (!priceData[ticker]) {
+          throw new Error(`Price data not available for ticker: ${ticker}`)
+        }
+        return priceData[ticker]
+      },
+      fetchPortfolio: async (userId: string): Promise<Portfolio> => {
+        // Check if we have a portfolio for this user
+        if (!portfolioData[userId]) {
+          throw new Error(`Portfolio not found for user: ${userId}`)
+        }
+        return portfolioData[userId]
+      }
+    }
+
+    // Create a schema for the task
+    const schema = new Schema({
+      userId: Schema.string()
+    })
+
+    // Create the portfolio value calculation task
+    calculatePortfolioValue = createTask(
+      schema,
+      boundaries,
+      async ({ userId }, { fetchPortfolio, fetchPrice }) => {
+        // First fetch the portfolio for the user
+        const portfolio = await fetchPortfolio(userId)
+
+        // Then calculate the value of each stock and the total portfolio value
+        const stocksWithValue = await Promise.all(
+          portfolio.stocks.map(async (stock) => {
+            const price = await fetchPrice(stock.ticker)
+            const value = price * stock.quantity
+
+            return {
+              ticker: stock.ticker,
+              quantity: stock.quantity,
+              price,
+              value
+            }
+          })
+        )
+
+        // Calculate total value
+        const totalValue = stocksWithValue.reduce((sum, stock) => sum + stock.value, 0)
+
+        // Return portfolio value information
+        return {
+          id: portfolio.id,
+          userId: portfolio.userId,
+          totalValue,
+          stocks: stocksWithValue
+        }
+      }
+    )
+  })
+
+  it('Should calculate portfolio value using multiple boundaries', async () => {
+    // Run the task for user1
+    const result = await calculatePortfolioValue.run({ userId: 'user1' })
+
+    // Verify the structure of the result
+    expect(result).toHaveProperty('id', 'portfolio1')
+    expect(result).toHaveProperty('userId', 'user1')
+    expect(result).toHaveProperty('totalValue')
+    expect(result).toHaveProperty('stocks')
+
+    // Verify portfolio calculations
+    expect(result.stocks).toHaveLength(3)
+
+    // Calculate expected values
+    const expectedTotalValue =
+      (priceData['AAPL'] * 10) +
+      (priceData['MSFT'] * 5) +
+      (priceData['GOOGL'] * 8)
+
+    // Verify total value matches expected
+    expect(result.totalValue).toBeCloseTo(expectedTotalValue)
+
+    // Verify each stock's value
+    const applStock = result.stocks.find((s: { ticker: string }) => s.ticker === 'AAPL')
+    expect(applStock).toBeDefined()
+    expect(applStock?.price).toBe(priceData['AAPL'])
+    expect(applStock?.value).toBeCloseTo(priceData['AAPL'] * 10)
+
+    const msftStock = result.stocks.find((s: { ticker: string }) => s.ticker === 'MSFT')
+    expect(msftStock).toBeDefined()
+    expect(msftStock?.price).toBe(priceData['MSFT'])
+    expect(msftStock?.value).toBeCloseTo(priceData['MSFT'] * 5)
+
+    const googlStock = result.stocks.find((s: { ticker: string }) => s.ticker === 'GOOGL')
+    expect(googlStock).toBeDefined()
+    expect(googlStock?.price).toBe(priceData['GOOGL'])
+    expect(googlStock?.value).toBeCloseTo(priceData['GOOGL'] * 8)
+  })
+
+  it('Should replay portfolio calculation from an execution log', async () => {
+    // First create a portfolio value calculation execution log
+    const executionLog: ExecutionRecord = {
+      input: { userId: 'user1' },
+      output: {
+        id: 'portfolio1',
+        userId: 'user1',
+        totalValue: 4363.02,
+        stocks: [
+          { ticker: 'AAPL', quantity: 10, price: 190.50, value: 1905.00 },
+          { ticker: 'MSFT', quantity: 5, price: 405.75, value: 2028.75 },
+          { ticker: 'GOOGL', quantity: 8, price: 161.16, value: 429.27 }
+        ]
+      },
+      boundaries: {
+        fetchPortfolio: [
+          {
+            input: ['user1'],
+            output: {
+              id: 'portfolio1',
+              userId: 'user1',
+              stocks: [
+                { ticker: 'AAPL', quantity: 10 },
+                { ticker: 'MSFT', quantity: 5 },
+                { ticker: 'GOOGL', quantity: 8 }
+              ]
+            }
+          }
+        ],
+        fetchPrice: [
+          {
+            input: ['AAPL'],
+            output: 190.50
+          },
+          {
+            input: ['MSFT'],
+            output: 405.75
+          },
+          {
+            input: ['GOOGL'],
+            output: 161.16
+          }
+        ]
+      }
+    }
+
+    // Use replay mode for all boundaries
+    const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
+      executionLog,
+      {
+        boundaries: {
+          fetchPortfolio: 'replay',
+          fetchPrice: 'replay'
+        }
+      }
+    )
+
+    // Verify there was no error
+    expect(replayError).toBeNull()
+
+    // Verify the replayed result
+    expect(replayResult).toHaveProperty('id', 'portfolio1')
+    expect(replayResult).toHaveProperty('userId', 'user1')
+    expect(replayResult).toHaveProperty('totalValue', 5223.03)
+    expect(replayResult).toHaveProperty('stocks')
+    expect(replayResult.stocks).toHaveLength(3)
+
+    // Check values match the execution log exactly
+    const applStock = replayResult.stocks.find((s: { ticker: string }) => s.ticker === 'AAPL')
+    expect(applStock?.price).toBe(190.50)
+    expect(applStock?.value).toBe(1905.00)
+
+    // Verify that boundary calls were properly replayed
+    expect(replayLog.boundaries.fetchPortfolio).toHaveLength(1)
+    expect(replayLog.boundaries.fetchPrice).toHaveLength(3)
+  })
+
+  it('Should handle errors during replay', async () => {
+    // Create an execution log with an error in one of the price fetches
+    const executionLog: ExecutionRecord = {
+      input: { userId: 'user1' },
+      error: 'Price data not available for ticker: GOOGL',
+      boundaries: {
+        fetchPortfolio: [
+          {
+            input: ['user1'],
+            output: {
+              id: 'portfolio1',
+              userId: 'user1',
+              stocks: [
+                { ticker: 'AAPL', quantity: 10 },
+                { ticker: 'MSFT', quantity: 5 },
+                { ticker: 'GOOGL', quantity: 8 }
+              ]
+            }
+          }
+        ],
+        fetchPrice: [
+          {
+            input: ['AAPL'],
+            output: 190.50
+          },
+          {
+            input: ['MSFT'],
+            output: 405.75
+          },
+          {
+            input: ['GOOGL'],
+            error: 'Price data not available for ticker: GOOGL'
+          }
+        ]
+      }
+    }
+
+    // Use replay mode for all boundaries
+    const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
+      executionLog,
+      {
+        boundaries: {
+          fetchPortfolio: 'replay',
+          fetchPrice: 'replay'
+        }
+      }
+    )
+
+    // Verify error was properly replayed
+    expect(replayResult).toBeNull()
+    expect(replayError).not.toBeNull()
+    expect(replayError?.message).toBe('Price data not available for ticker: GOOGL')
+
+    // Verify that boundary calls were properly replayed up to the error
+    expect(replayLog.boundaries.fetchPortfolio).toHaveLength(1)
+    expect(replayLog.boundaries.fetchPrice).toHaveLength(3)
+
+    // Check the error in the boundary
+    const googPriceCall = replayLog.boundaries.fetchPrice.find(
+      (call: { input?: unknown[] }) => call.input && call.input[0] === 'GOOGL'
+    )
+    expect(googPriceCall).toBeDefined()
+    expect(googPriceCall?.error).toBe('Price data not available for ticker: GOOGL')
+  })
+
+  it('Should support mixed replay with some boundaries in replay mode and others in proxy mode', async () => {
+    // Update prices for the test
+    priceData['AAPL'] = 195.00 // Different from replay data
+
+    // Create an execution log with historical data
+    const executionLog: ExecutionRecord = {
+      input: { userId: 'user1' },
+      output: {
+        id: 'portfolio1',
+        userId: 'user1',
+        totalValue: 4363.02,
+        stocks: [
+          { ticker: 'AAPL', quantity: 10, price: 190.50, value: 1905.00 },
+          { ticker: 'MSFT', quantity: 5, price: 405.75, value: 2028.75 },
+          { ticker: 'GOOGL', quantity: 8, price: 161.16, value: 429.27 }
+        ]
+      },
+      boundaries: {
+        fetchPortfolio: [
+          {
+            input: ['user1'],
+            output: {
+              id: 'portfolio1',
+              userId: 'user1',
+              stocks: [
+                { ticker: 'AAPL', quantity: 10 },
+                { ticker: 'MSFT', quantity: 5 },
+                { ticker: 'GOOGL', quantity: 8 }
+              ]
+            }
+          }
+        ],
+        fetchPrice: [
+          {
+            input: ['AAPL'],
+            output: 190.50
+          },
+          {
+            input: ['MSFT'],
+            output: 405.75
+          },
+          {
+            input: ['GOOGL'],
+            output: 161.16
+          }
+        ]
+      }
+    }
+
+    // Use replay mode for portfolio but proxy mode for prices
+    const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
+      executionLog,
+      {
+        boundaries: {
+          fetchPortfolio: 'replay', // Use replay for portfolio
+          fetchPrice: 'proxy'       // Use proxy (real execution) for prices
+        }
+      }
+    )
+
+    // Verify there was no error
+    expect(replayError).toBeNull()
+
+    // The result should reflect the updated AAPL price of 195.00
+    expect(replayResult).toHaveProperty('id', 'portfolio1')
+    expect(replayResult).toHaveProperty('userId', 'user1')
+
+    // Calculate expected value with current prices
+    const expectedValue =
+      (priceData['AAPL'] * 10) +   // AAPL: 195.00 * 10
+      (priceData['MSFT'] * 5) +    // MSFT: 421.90 * 5
+      (priceData['GOOGL'] * 8)    // GOOGL: 171.04 * 8
+
+    expect(replayResult.totalValue).toBeCloseTo(expectedValue)
+
+    // Check AAPL price reflects the current price, not the replay data
+    const applStock = replayResult.stocks.find((s: { ticker: string }) => s.ticker === 'AAPL')
+    expect(applStock?.price).toBe(195.00)
+    expect(applStock?.value).toBeCloseTo(195.00 * 10)
+
+    // Verify the log shows the mixed sources correctly
+    expect(replayLog.boundaries.fetchPortfolio).toHaveLength(1)
+    expect(replayLog.boundaries.fetchPrice).toHaveLength(3)
+  })
+})

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

@@ -0,0 +1,189 @@
+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')
+  })
+})

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?: undefined;
 }
 
+/**
+ * Error record for a boundary function call
+ * @template TInput - The type of input data
+ */
+export type BoundaryErrorRecord<TInput = unknown[]> = {
+  input: TInput;
+  output?: undefined;
+  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) {
           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>
       }