@forgehive/task 0.1.7 → 0.1.9

package/src/index.ts

@@ -1,5 +1,13 @@
 import { Schema, type SchemaType, type InferSchema, type SchemaDescription } from '@forgehive/schema'
-import { createBoundary, type Mode, type Boundaries, type WrappedBoundaries, type WrappedBoundaryFunction } from './utils/boundary'
+import {
+  createBoundary,
+  type Mode,
+  type Boundaries,
+  type WrappedBoundaries,
+  type WrappedBoundaryFunction,
+  type BoundaryRecord,
+  type BoundaryTapeData
+} from './utils/boundary'
 
 export interface Task {
   id: string;
@@ -11,7 +19,17 @@ export interface Task {
 export type BaseFunction = (...args: any[]) => any
 
 // Re-export the boundary types for external use
-export type { BoundaryFunction, WrappedBoundaryFunction, Boundaries, WrappedBoundaries, Mode } from './utils/boundary'
+export type {
+  BoundaryFunction,
+  WrappedBoundaryFunction,
+  Boundaries,
+  WrappedBoundaries,
+  Mode,
+  BoundarySuccessRecord,
+  BoundaryErrorRecord,
+  BoundaryRecord,
+  BoundaryTapeData
+} from './utils/boundary'
 
 // Re-export Schema for external use
 export { Schema }
@@ -20,7 +38,14 @@ export interface TaskConfig<B extends Boundaries = Boundaries> {
   schema?: Schema<Record<string, SchemaType>>
   mode?: Mode
   boundaries?: B
-  boundariesData?: Record<string, unknown>
+  boundariesData?: BoundaryTapeData
+}
+
+// Interface for safeReplay configuration
+export interface ReplayConfig<B extends Boundaries = Boundaries> {
+  boundaries: {
+    [K in keyof B]?: Mode
+  }
 }
 
 // ToDo: Add a type for the boundaries data
@@ -39,11 +64,7 @@ export interface TaskRecord<InputType = unknown, OutputType = unknown> {
 }
 
 // Make BoundaryLog generic
-export type BoundaryLog<I extends unknown[] = unknown[], O = unknown> = {
-  input: I
-  output: O | null
-  error: string | null
-}
+export type BoundaryLog<I extends unknown[] = unknown[], O = unknown> = BoundaryRecord<I, O>;
 
 // Mapped type for boundaries
 export type BoundaryLogsFor<B extends Boundaries> = {
@@ -89,7 +110,7 @@ export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B ex
   // Boundary methods
   asBoundary: () => (args: Parameters<Func>[0]) => Promise<ReturnType<Func>>
   getBoundaries: () => WrappedBoundaries<B>
-  setBoundariesData: (boundariesData: Record<string, unknown>) => void
+  setBoundariesData: (boundariesData: BoundaryTapeData) => void
   getBondariesData: () => Record<string, unknown>
 
   // Mocking methods for testing
@@ -99,8 +120,17 @@ export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B ex
 
   run: (argv?: Parameters<Func>[0]) => Promise<ReturnType<Func>>
   safeRun: (argv?: Parameters<Func>[0]) => Promise<[ReturnType<Func> | null, Error | null, ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>]>
+
+  // Method for replaying task execution
+  safeReplay: (
+    executionLog: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>,
+    config: ReplayConfig<B>
+  ) => Promise<[ReturnType<Func> | null, Error | null, ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>]>
 }
 
+// Define a type for the accumulated boundary data
+type BoundaryData = Array<{input: unknown[], output?: unknown}>
+
 // Helper type to infer schema type
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type InferSchemaType<S> = S extends Schema<any> ? InferSchema<S> : Record<string, unknown>;
@@ -110,9 +140,6 @@ export type TaskFunction<S, B extends Boundaries> =
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   (argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<any>;
 
-// Define a type for the accumulated boundary data
-type BoundaryData = Array<{input: unknown[], output?: unknown}>
-
 export const Task = class Task<
   B extends Boundaries = Boundaries,
   Func extends BaseFunction = BaseFunction
@@ -125,7 +152,7 @@ export const Task = class Task<
   _description?: string
 
   _boundariesDefinition: B
-  _boundariesData: Record<string, unknown> | null
+  _boundariesData: BoundaryTapeData | null
   _accumulatedBoundariesData: Record<string, BoundaryData> = {}
 
   // For storing mocks
@@ -250,7 +277,7 @@ export const Task = class Task<
     })
   }
 
-  setBoundariesData (boundariesData: Record<string, unknown>): void {
+  setBoundariesData (boundariesData: BoundaryTapeData): void {
     this._boundariesData = boundariesData
 
     // Update accumulated data as well
@@ -297,31 +324,36 @@ export const Task = class Task<
   _createBounderies ({
     definition,
     baseData,
-    mode = 'proxy'
+    mode = 'proxy',
+    boundaryModes = {}
   }: {
     definition: B;
-    baseData: Record<string, unknown> | null;
+    baseData: BoundaryTapeData | null;
     mode?: Mode;
+    boundaryModes?: Record<string, Mode | undefined>;
   }): WrappedBoundaries<B> {
     const boundariesFns: Record<string, WrappedBoundaryFunction> = {}
 
     for (const name in definition) {
+      // Get the configured mode for this boundary or use default
+      const boundaryMode = boundaryModes[name] || mode
+
       // Check if we have a mock for this boundary
       if (this._boundaryMocks[name]) {
         boundariesFns[name] = this._boundaryMocks[name]
         continue
       }
 
-      // Otherwise create the normal boundary
+      // Create the boundary
       const boundary = createBoundary(definition[name])
 
       if (baseData !== null && typeof baseData[name] !== 'undefined') {
-        const tape = baseData[name]
-
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        boundary.setTape(tape as any)
+        const boundaryData = baseData[name] as Array<BoundaryRecord<Parameters<B[Extract<keyof B, string>]>, Awaited<ReturnType<B[Extract<keyof B, string>]>>>>
+        boundary.setTape(boundaryData)
       }
-      boundary.setMode(mode as Mode)
+
+      // Set the mode after setting the tape
+      boundary.setMode(boundaryMode)
 
       boundariesFns[name] = boundary
     }
@@ -436,6 +468,120 @@ export const Task = class Task<
     return [output, error, logItem]
   }
 
+  async safeReplay(
+    executionLog: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>,
+    config: ReplayConfig<B> = {
+      boundaries: {}
+    }
+  ): Promise<[
+    ReturnType<Func> | null,
+    Error | null,
+    ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>
+  ]> {
+    // Extract the input from the execution log
+    const argv = executionLog.input
+
+    // Initialize log item for this replay
+    const logItem: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B> = {
+      input: argv,
+      boundaries: {} as BoundaryLogsFor<B>
+    }
+
+    // Create boundaries for this replay execution with custom modes based on config
+    const boundariesConfig: BoundaryTapeData = {}
+
+    // Setup boundary data for replay mode boundaries
+    for (const name in this._boundariesDefinition) {
+      // Check if this boundary is configured for replay mode
+      const mode = config.boundaries[name] || 'proxy'
+
+      if (mode === 'replay' && executionLog.boundaries[name]) {
+        // Add boundary data from the execution log for replay mode
+        boundariesConfig[name] = executionLog.boundaries[name]
+      }
+    }
+
+    // Create fresh boundaries for this execution
+    const executionBoundaries = this._createBounderies({
+      definition: this._boundariesDefinition,
+      baseData: boundariesConfig,
+      mode: 'proxy',
+      boundaryModes: config.boundaries
+    })
+
+    // Start run for each boundary
+    for (const name in executionBoundaries) {
+      const boundary = executionBoundaries[name]
+      boundary.startRun()
+    }
+
+    // Handle schema validation - reusing the input from the execution log
+    if (this._schema) {
+      const validation = this._schema.safeParse(argv)
+      if (!validation.success) {
+        const errorDetails = validation.error?.errors.map(err =>
+          `${err.path.join('.')}: ${err.message}`
+        ).join(', ')
+
+        const errorMessage = errorDetails
+          ? `Invalid input on: ${errorDetails}`
+          : 'Invalid input'
+
+        logItem.error = errorMessage
+        logItem.output = executionLog.output // Keep the original output
+
+        // Copy the boundary data from the execution log
+        logItem.boundaries = executionLog.boundaries
+
+        this.emit(logItem)
+        return [null, new Error(errorMessage), logItem]
+      }
+    }
+
+    let output: ReturnType<Func> | null = null
+    let error: Error | null = null
+
+    try {
+      // Execute the task function with replay boundaries
+      output = await this._fn(
+        argv,
+        executionBoundaries as unknown as Parameters<Func>[1]
+      )
+
+      logItem.output = output
+    } catch (caughtError) {
+      const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError)
+      logItem.error = errorMessage
+      error = new Error(errorMessage)
+    }
+
+    // Process boundary data after execution
+    const boundariesRunLog: BoundaryLogsFor<B> = {} as BoundaryLogsFor<B>
+
+    for (const name in executionBoundaries) {
+      const boundary = executionBoundaries[name]
+      const runData = boundary.getRunData()
+
+      // For boundaries in replay mode, use the original log data instead
+      const mode = config.boundaries[name] || 'proxy'
+      if (mode === 'replay' && executionLog.boundaries[name]) {
+        boundariesRunLog[name as keyof B] = executionLog.boundaries[name as keyof B]
+      } else {
+        // For other modes, use the actual run data
+        boundariesRunLog[name as keyof B] = runData as unknown as BoundaryLogsFor<B>[typeof name]
+      }
+    }
+
+    // Set boundaries in log item before emitting
+    logItem.boundaries = boundariesRunLog
+
+    // Emit the log item
+    this.emit(logItem)
+
+    // Return the output, error, and log item
+    return [output, error, logItem]
+  }
+
   async run (argv?: Parameters<Func>[0]): Promise<ReturnType<Func>> {
     const [result, error] = await this.safeRun(argv)
 

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)
+  })
+})