@forgehive/task 0.1.5 → 0.1.7

package/src/index.ts

@@ -23,6 +23,7 @@ export interface TaskConfig<B extends Boundaries = Boundaries> {
   boundariesData?: Record<string, unknown>
 }
 
+// ToDo: Add a type for the boundaries data
 /**
  * Represents the record passed to task listeners
  */
@@ -37,7 +38,37 @@ export interface TaskRecord<InputType = unknown, OutputType = unknown> {
   boundaries?: Record<string, unknown>;
 }
 
+// Make BoundaryLog generic
+export type BoundaryLog<I extends unknown[] = unknown[], O = unknown> = {
+  input: I
+  output: O | null
+  error: string | null
+}
+
+// Mapped type for boundaries
+export type BoundaryLogsFor<B extends Boundaries> = {
+  [K in keyof B]: B[K] extends (...args: infer I) => Promise<infer O>
+    ? BoundaryLog<I, O>[]
+    : BoundaryLog[]
+}
+
+/**
+ * Represents the execution record of a task, including input, output, error, and boundary data
+ */
+export interface ExecutionRecord<InputType = unknown, OutputType = unknown, B extends Boundaries = Boundaries> {
+  /** The input arguments passed to the task */
+  input: InputType
+  /** The output returned by the task (if successful) */
+  output?: OutputType | null
+  /** The error message if the task failed */
+  error?: string
+  /** Boundary execution data */
+  boundaries: BoundaryLogsFor<B>
+}
+
 export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B extends Boundaries = Boundaries> {
+  version: string
+
   getMode: () => Mode
   setMode: (mode: Mode) => void
   setSchema: (base: Schema<Record<string, SchemaType>>) => void
@@ -60,9 +91,14 @@ export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B ex
   getBoundaries: () => WrappedBoundaries<B>
   setBoundariesData: (boundariesData: Record<string, unknown>) => void
   getBondariesData: () => Record<string, unknown>
-  getBondariesRunLog: () => Record<string, unknown>
-  startRunLog: () => void
+
+  // Mocking methods for testing
+  mockBoundary: <K extends keyof B>(name: K, mockFn: WrappedBoundaryFunction) => void
+  resetMock: <K extends keyof B>(name: K) => void
+  resetMocks: () => void
+
   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>]>
 }
 
 // Helper type to infer schema type
@@ -74,18 +110,26 @@ 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
 > implements TaskInstanceType<Func, B> {
+  public version: string = '0.1.7'
+
   _fn: Func
   _mode: Mode
   _coolDown: number
   _description?: string
 
   _boundariesDefinition: B
-  _boundaries: WrappedBoundaries<B>
   _boundariesData: Record<string, unknown> | null
+  _accumulatedBoundariesData: Record<string, BoundaryData> = {}
+
+  // For storing mocks
+  _boundaryMocks: Record<string, WrappedBoundaryFunction> = {}
 
   _schema: Schema<Record<string, SchemaType>> | undefined
   _listener?: ((record: TaskRecord<Parameters<Func>[0], ReturnType<Func>>) => void) | undefined
@@ -110,13 +154,25 @@ export const Task = class Task<
     // Cool down time before killing the process on cli runner
     this._coolDown = 1000
 
-    // Review this assignment
+    // Initialize boundaries data
     this._boundariesData = conf.boundariesData ?? null
-    this._boundaries = this._createBounderies({
-      definition: this._boundariesDefinition,
-      baseData: this._boundariesData,
-      mode: this._mode
-    })
+
+    // Initialize empty accumulated boundaries data structure
+    for (const name in this._boundariesDefinition) {
+      this._accumulatedBoundariesData[name] = []
+    }
+
+    // Initialize accumulated boundaries data from initial boundaries data
+    if (this._boundariesData) {
+      // Type assertion to handle initial data safely
+      for (const name in this._boundariesData) {
+        if (Array.isArray(this._boundariesData[name])) {
+          this._accumulatedBoundariesData[name] = this._boundariesData[name] as BoundaryData
+        } else {
+          this._accumulatedBoundariesData[name] = []
+        }
+      }
+    }
   }
 
   getMode (): Mode {
@@ -124,12 +180,6 @@ export const Task = class Task<
   }
 
   setMode (mode: Mode): void {
-    for (const name in this._boundaries) {
-      const boundary = this._boundaries[name]
-
-      boundary.setMode(mode)
-    }
-
     this._mode = mode
   }
 
@@ -188,45 +238,60 @@ export const Task = class Task<
   emit (data: Partial<TaskRecord>): void {
     if (typeof this._listener === 'undefined') { return }
 
-    const event = {
-      ...data,
-      boundaries: this.getBondariesRunLog()
-    } as TaskRecord<Parameters<Func>[0], ReturnType<Func>>
-
-    this._listener(event)
+    this._listener(data as TaskRecord<Parameters<Func>[0], ReturnType<Func>>)
   }
 
   getBoundaries (): WrappedBoundaries<B> {
-    return this._boundaries
+    // Create fresh boundaries when requested
+    return this._createBounderies({
+      definition: this._boundariesDefinition,
+      baseData: this._boundariesData,
+      mode: this._mode
+    })
   }
 
   setBoundariesData (boundariesData: Record<string, unknown>): void {
-    for (const name in this._boundaries) {
-      const boundary = this._boundaries[name]
-
-      let tape
-      if (typeof boundariesData !== 'undefined') {
-        tape = boundariesData[name]
-      }
-
-      if (typeof boundary !== 'undefined' && typeof tape !== 'undefined') {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        boundary.setTape(tape as any)
+    this._boundariesData = boundariesData
+
+    // Update accumulated data as well
+    // Type assertion to handle provided data safely
+    for (const name in boundariesData) {
+      if (Array.isArray(boundariesData[name])) {
+        this._accumulatedBoundariesData[name] = boundariesData[name] as BoundaryData
+      } else {
+        this._accumulatedBoundariesData[name] = []
       }
     }
   }
 
   getBondariesData (): Record<string, unknown> {
-    const boundaries = this._boundaries
-    const boundariesData: Record<string, unknown> = {}
+    return this._accumulatedBoundariesData
+  }
 
-    for (const name in boundaries) {
-      const boundary = boundaries[name]
+  /**
+   * Mocks a specific boundary function for testing
+   * @param name The name of the boundary to mock
+   * @param mockFn The mock function to use
+   */
+  mockBoundary<K extends keyof B>(name: K, mockFn: WrappedBoundaryFunction): void {
+    this._boundaryMocks[name as string] = mockFn
+  }
 
-      boundariesData[name] = boundary.getTape()
+  /**
+   * Resets a specific mocked boundary back to its original function
+   * @param name The name of the boundary to reset
+   */
+  resetMock<K extends keyof B>(name: K): void {
+    if (this._boundaryMocks[name as string]) {
+      delete this._boundaryMocks[name as string]
     }
+  }
 
-    return boundariesData
+  /**
+   * Resets all mocked boundaries back to their original functions
+   */
+  resetMocks(): void {
+    this._boundaryMocks = {}
   }
 
   _createBounderies ({
@@ -241,6 +306,13 @@ export const Task = class Task<
     const boundariesFns: Record<string, WrappedBoundaryFunction> = {}
 
     for (const name in definition) {
+      // Check if we have a mock for this boundary
+      if (this._boundaryMocks[name]) {
+        boundariesFns[name] = this._boundaryMocks[name]
+        continue
+      }
+
+      // Otherwise create the normal boundary
       const boundary = createBoundary(definition[name])
 
       if (baseData !== null && typeof baseData[name] !== 'undefined') {
@@ -257,87 +329,121 @@ export const Task = class Task<
     return boundariesFns as WrappedBoundaries<B>
   }
 
-  getBondariesRunLog (): Record<string, unknown> {
-    const boundaries = this._boundaries
-    const boundariesRunLog: Record<string, unknown> = {}
+  asBoundary (): (args: Parameters<Func>[0]) => Promise<ReturnType<Func>> {
+    return async (args: Parameters<Func>[0]): Promise<ReturnType<Func>> => {
+      return await this.run(args)
+    }
+  }
+
+  async safeRun (argv?: Parameters<Func>[0]): Promise<[
+    ReturnType<Func> | null,
+    Error | null,
+    ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>
+  ]> {
+    // Initialize log item
+    const logItem: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B> = {
+      input: argv as Parameters<Func>[0],
+      boundaries: {} as BoundaryLogsFor<B>
+    }
 
-    for (const name in boundaries) {
-      const boundary = boundaries[name]
+    // Create fresh boundaries for this execution
+    const executionBoundaries = this._createBounderies({
+      definition: this._boundariesDefinition,
+      baseData: this._boundariesData,
+      mode: this._mode
+    })
 
-      boundariesRunLog[name] = boundary.getRunData()
+    // Start run for each boundary
+    for (const name in executionBoundaries) {
+      const boundary = executionBoundaries[name]
+      boundary.startRun()
     }
 
-    return boundariesRunLog
-  }
+    // Handle schema validation
+    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(', ')
 
-  startRunLog (): void {
-    const boundaries = this._boundaries
+        const errorMessage = errorDetails
+          ? `Invalid input on: ${errorDetails}`
+          : 'Invalid input'
 
-    for (const name in boundaries) {
-      const boundary = boundaries[name]
+        logItem.error = errorMessage
+        logItem.boundaries = {} as BoundaryLogsFor<B>
 
-      boundary.startRun()
+        // Add boundary elements empty
+        for (const name in executionBoundaries) {
+          logItem.boundaries[name as keyof B] = [] as unknown as BoundaryLogsFor<B>[typeof name]
+        }
+
+        this.emit(logItem)
+        return [null, new Error(errorMessage), logItem]
+      }
     }
-  }
 
-  asBoundary (): (args: Parameters<Func>[0]) => Promise<ReturnType<Func>> {
-    return async (args: Parameters<Func>[0]): Promise<ReturnType<Func>> => {
-      return await this.run(args)
+    let output: ReturnType<Func> | null = null
+    let error: Error | null = null
+
+    try {
+      // Execute the task function
+      output = await this._fn(
+        argv as Parameters<Func>[0],
+        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)
     }
-  }
 
-  async run (argv?: Parameters<Func>[0]): Promise<ReturnType<Func>> {
-    // start run log
-    this.startRunLog()
-    const boundaries = this._boundaries
+    // Process boundary data after execution (both success and error cases)
+    const boundariesRunLog: BoundaryLogsFor<B> = {} as BoundaryLogsFor<B>
 
-    const q = new Promise<ReturnType<Func>>((resolve, reject) => {
-      if (this._schema) {
-        const validation = this._schema.safeParse(argv)
+    for (const name in executionBoundaries) {
+      const boundary = executionBoundaries[name]
+      const runData = boundary.getRunData()
 
-        if (!validation.success) {
-          const errorDetails = validation.error?.errors.map(err =>
-            `${err.path.join('.')}: ${err.message}`
-          ).join(', ')
+      // Add to the run log
+      boundariesRunLog[name as keyof B] = runData as unknown as BoundaryLogsFor<B>[typeof name]
 
-          const errorMessage = errorDetails
-            ? `Invalid input on: ${errorDetails}`
-            : 'Invalid input'
+      // Accumulate in the task's total boundaries data
+      if (!this._accumulatedBoundariesData[name]) {
+        this._accumulatedBoundariesData[name] = []
+      }
 
-          this.emit({
-            input: argv,
-            error: errorMessage
-          })
+      // Get the current accumulated data for this boundary
+      const currentData = this._accumulatedBoundariesData[name]
 
-          throw new Error(errorMessage)
-        }
+      // Add the new run data
+      if (Array.isArray(runData) && runData.length > 0) {
+        // Cast the run data to the correct type
+        this._accumulatedBoundariesData[name] = [...currentData, ...(runData as BoundaryData)]
       }
+    }
 
-      (async (): Promise<ReturnType<Func>> => {
-        // Use proper typing for the function call
-        const output = await this._fn(argv as Parameters<Func>[0], boundaries as unknown as Parameters<Func>[1])
-
-        return output
-      })().then((output) => {
-        this.emit({
-          input: argv,
-          output
-        })
-
-        resolve(output)
-      }).catch((error) => {
-        this.emit({
-          input: argv,
-          error: error.message
-        })
-
-        reject(error)
-      })
-    })
+    // Set boundaries in log item before emitting
+    logItem.boundaries = boundariesRunLog
 
-    const result = await q
+    // Emit the log item
+    this.emit(logItem)
 
-    return result
+    // Return the error, output and log item
+    return [output, error, logItem]
+  }
+
+  async run (argv?: Parameters<Func>[0]): Promise<ReturnType<Func>> {
+    const [result, error] = await this.safeRun(argv)
+
+    if (error) {
+      throw error
+    }
+
+    return result as ReturnType<Func>
   }
 }
 

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

@@ -0,0 +1,241 @@
+import { createTask, Schema } from '../index'
+
+describe('Task safeRun tests', () => {
+  it('returns [result, null, record] on successful execution', async () => {
+    // Create a simple schema
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchData: async (value: number): Promise<number> => {
+        return value * 2
+      }
+    }
+
+    // Create the task
+    const successTask = createTask(
+      schema,
+      boundaries,
+      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 })
+
+    // Verify success case
+    expect(error).toBeNull()
+    expect(result).toEqual({ result: 10, success: true })
+    expect(record).not.toBeNull()
+    expect(record).toHaveProperty('boundaries.fetchData')
+    expect(record.boundaries.fetchData).toHaveLength(1)
+
+    // useful to check types on record
+    const data = record.boundaries.fetchData[0]
+    expect(data.input).toEqual([5])
+    expect(data.output).toEqual(10)
+    expect(data.error).toBeUndefined()
+  })
+
+  it('returns [null, error, record] on failed execution', async () => {
+    // Create a simple schema
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries with a function that will throw an error
+    const boundaries = {
+      fetchData: async (value: number): Promise<number> => {
+        if (value < 0) {
+          throw new Error('Value cannot be negative')
+        }
+        return value * 2
+      }
+    }
+
+    // Create the task
+    const errorTask = createTask(
+      schema,
+      boundaries,
+      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 })
+
+    // Verify error case
+    expect(error).not.toBeNull()
+    expect(error instanceof Error).toBe(true)
+    if (error instanceof Error) {
+      expect(error.message).toContain('Value cannot be negative')
+    }
+    expect(result).toBeNull()
+    expect(record).not.toBeNull()
+    expect(record).toHaveProperty('boundaries.fetchData')
+    expect(record.boundaries.fetchData).toHaveLength(1)
+
+    const data = record.boundaries.fetchData[0]
+    expect(data.input).toEqual([-5])
+    expect(data.error).toContain('Value cannot be negative')
+    expect(data.output).toBeUndefined()
+  })
+
+  it('returns [null, error, record] on schema validation failure', async () => {
+    // Create a schema that requires a positive number
+    const schema = new Schema({
+      value: Schema.number().min(1, 'Value must be positive')
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchData: async (value: number): Promise<number> => {
+        return value * 2
+      }
+    }
+
+    // Create the task
+    const validationTask = createTask(
+      schema,
+      boundaries,
+      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 })
+
+    // Verify validation error case
+    expect(error).toBeInstanceOf(Error)
+    expect(error instanceof Error).toBe(true)
+    if (error instanceof Error) {
+      expect(error.message).toContain('Value must be positive')
+    }
+    expect(result).toBeNull()
+    expect(record).not.toBeNull()
+    expect(record.input).toEqual({ value: 0 })
+    expect(record.error).toContain('Value must be positive')
+    expect(record.boundaries).toEqual({
+      fetchData: []
+    })
+  })
+
+  it('properly calls the listener with safeRun and run', async () => {
+    // Create a schema
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchData: async (value: number): Promise<number> => {
+        return value * 2
+      }
+    }
+
+    // Create the task
+    const listenerTask = createTask(
+      schema,
+      boundaries,
+      async function ({ value }, { fetchData }) {
+        const result = await fetchData(value)
+        return result
+      }
+    )
+
+    // Create a mock listener
+    const originalListener = jest.fn()
+    listenerTask.addListener(originalListener)
+
+    // Call safeRun - this should call the listener once
+    await listenerTask.safeRun({ value: 10 })
+
+    // Run the task normally - this should call the listener again through safeRun
+    await listenerTask.run({ value: 20 })
+
+    // The original listener should have been called for both runs
+    expect(originalListener).toHaveBeenCalledTimes(2)
+
+    // First call should be for safeRun with value 10
+    expect(originalListener).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        input: { value: 10 },
+        output: 20,
+        boundaries: {
+          fetchData: expect.any(Array)
+        }
+      })
+    )
+
+    // Second call should be for run with value 20
+    expect(originalListener).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        input: { value: 20 },
+        output: 40,
+        boundaries: {
+          fetchData: expect.any(Array)
+        }
+      })
+    )
+  })
+
+  it('handles multiple boundary calls correctly', async () => {
+    // Create a schema
+    const schema = new Schema({
+      values: Schema.array(Schema.number())
+    })
+
+    // Define multiple boundaries
+    const boundaries = {
+      doubleValue: async (value: number): Promise<number> => {
+        return value * 2
+      },
+      sumValues: async (values: number[]): Promise<number> => {
+        return values.reduce((sum, val) => sum + val, 0)
+      }
+    }
+
+    // Create a task that uses multiple boundaries
+    const multiBoundaryTask = createTask(
+      schema,
+      boundaries,
+      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] })
+
+    // Verify success
+    expect(error).toBeNull()
+    expect(result).toEqual({
+      doubled: [2, 4, 6],
+      total: 12
+    })
+
+    // Verify record structure
+    expect(record).not.toBeNull()
+    expect(record).toHaveProperty('boundaries.doubleValue')
+    expect(record).toHaveProperty('boundaries.sumValues')
+
+    expect(record.boundaries.doubleValue).toHaveLength(3)
+    expect(record.boundaries.sumValues).toHaveLength(1)
+    expect(record.boundaries.doubleValue[0]).toEqual({ input: [1], output: 2 })
+    expect(record.boundaries.doubleValue[1]).toEqual({ input: [2], output: 4 })
+    expect(record.boundaries.doubleValue[2]).toEqual({ input: [3], output: 6 })
+    expect(record.boundaries.sumValues[0]).toEqual({ input: [[2, 4, 6]], output: 12 })
+  })
+})