@forgehive/task 0.1.4 → 0.1.6

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
  */
@@ -60,9 +61,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<[Error | null, ReturnType<Func> | null, Record<string, unknown> | null]>
 }
 
 // Helper type to infer schema type
@@ -74,6 +80,9 @@ 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
@@ -84,8 +93,11 @@ export const Task = class Task<
   _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 +122,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 +148,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 +206,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 +274,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,77 +297,137 @@ export const Task = class Task<
     return boundariesFns as WrappedBoundaries<B>
   }
 
-  getBondariesRunLog (): Record<string, unknown> {
-    const boundaries = this._boundaries
-    const boundariesRunLog: Record<string, unknown> = {}
-
-    for (const name in boundaries) {
-      const boundary = boundaries[name]
-
-      boundariesRunLog[name] = boundary.getRunData()
+  asBoundary (): (args: Parameters<Func>[0]) => Promise<ReturnType<Func>> {
+    return async (args: Parameters<Func>[0]): Promise<ReturnType<Func>> => {
+      return await this.run(args)
     }
-
-    return boundariesRunLog
   }
 
-  startRunLog (): void {
-    const boundaries = this._boundaries
+  async safeRun (argv?: Parameters<Func>[0]): Promise<[Error | null, ReturnType<Func> | null, Record<string, unknown> | null]> {
+    // Handle schema validation
+    if (this._schema) {
+      try {
+        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'
+
+          // Emit the validation error
+          this.emit({
+            input: argv,
+            error: errorMessage
+          })
+
+          return [new Error(errorMessage), null, null]
+        }
+      } catch (error) {
+        return [error instanceof Error ? error : new Error(String(error)), null, null]
+      }
+    }
 
-    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
+    })
 
+    // Start run for each boundary
+    for (const name in executionBoundaries) {
+      const boundary = executionBoundaries[name]
       boundary.startRun()
     }
-  }
 
-  asBoundary (): (args: Parameters<Func>[0]) => Promise<ReturnType<Func>> {
-    return async (args: Parameters<Func>[0]): Promise<ReturnType<Func>> => {
-      return await this.run(args)
-    }
-  }
+    try {
+      // Execute the task function
+      const output = await this._fn(
+        argv as Parameters<Func>[0],
+        executionBoundaries as unknown as Parameters<Func>[1]
+      )
 
-  async run (argv?: Parameters<Func>[0]): Promise<ReturnType<Func>> {
-    // start run log
-    this.startRunLog()
-    const boundaries = this._boundaries
+      // Process boundary data after successful execution
+      const boundariesRunLog: Record<string, unknown> = {}
+
+      for (const name in executionBoundaries) {
+        const boundary = executionBoundaries[name]
+        const runData = boundary.getRunData()
+
+        // Add to the run log
+        boundariesRunLog[name] = runData
 
-    const q = new Promise<ReturnType<Func>>((resolve, reject) => {
-      const isValid = this.isValid(argv)
+        // Accumulate in the task's total boundaries data
+        if (!this._accumulatedBoundariesData[name]) {
+          this._accumulatedBoundariesData[name] = []
+        }
 
-      if (!isValid) {
-        this.emit({
-          input: argv,
-          error: 'Invalid input'
-        })
+        // Get the current accumulated data for this boundary
+        const currentData = this._accumulatedBoundariesData[name]
 
-        throw new Error('Invalid input')
+        // 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)
+      // Emit the success event with boundary data
+      this.emit({
+        input: argv,
+        output,
+        boundaries: boundariesRunLog
       })
-    })
 
-    const result = await q
+      return [null, output, boundariesRunLog]
+    } catch (error) {
+      // Process boundary data after error
+      const boundariesRunLog: Record<string, unknown> = {}
 
-    return result
+      for (const name in executionBoundaries) {
+        const boundary = executionBoundaries[name]
+        const runData = boundary.getRunData()
+
+        // Add to the run log
+        boundariesRunLog[name] = runData
+
+        // Accumulate in the task's total boundaries data
+        if (!this._accumulatedBoundariesData[name]) {
+          this._accumulatedBoundariesData[name] = []
+        }
+
+        // Get the current accumulated data for this boundary
+        const currentData = this._accumulatedBoundariesData[name]
+
+        // 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)]
+        }
+      }
+
+      // Emit the error event with boundary data
+      this.emit({
+        input: argv,
+        error: error instanceof Error ? error.message : String(error),
+        boundaries: boundariesRunLog
+      })
+
+      return [error instanceof Error ? error : new Error(String(error)), null, boundariesRunLog]
+    }
+  }
+
+  async run (argv?: Parameters<Func>[0]): Promise<ReturnType<Func>> {
+    const [error, result] = await this.safeRun(argv)
+
+    if (error) {
+      throw error
+    }
+
+    return result as ReturnType<Func>
   }
 }
 

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

@@ -64,7 +64,9 @@ describe('Listener tests', () => {
 
     expect(tape.length).toBe(1)
     expect(tape[0].input).toEqual({ value: 3 })
-    expect(tape[0].error).toBe('Invalid input')
+    expect(tape[0].error).toContain('Invalid input on:')
+    expect(tape[0].error).toContain('value:')
+    expect(tape[0].error).toContain('Number must be greater than or equal to 5')
   })
 
   it('Should record multiple records', async () => {

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

@@ -0,0 +1,214 @@
+import { createTask, Schema } from '../index'
+
+describe('Task safeRun tests', () => {
+  it('returns [null, result, boundaryLogs] 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 [error, result, boundaryLogs] = await successTask.safeRun({ value: 5 })
+
+    // Verify success case
+    expect(error).toBeNull()
+    expect(result).toEqual({ result: 10, success: true })
+    expect(boundaryLogs).not.toBeNull()
+    expect(boundaryLogs).toHaveProperty('fetchData')
+  })
+
+  it('returns [error, null, boundaryLogs] 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 [error, result, boundaryLogs] = await errorTask.safeRun({ value: -5 })
+
+    // Verify error case
+    expect(error).toBeInstanceOf(Error)
+    expect(error?.message).toContain('Value cannot be negative')
+    expect(result).toBeNull()
+    expect(boundaryLogs).not.toBeNull()
+    expect(boundaryLogs).toHaveProperty('fetchData')
+  })
+
+  it('returns [error, null, null] 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 [error, result, boundaryLogs] = await validationTask.safeRun({ value: 0 })
+
+    // Verify validation error case
+    expect(error).toBeInstanceOf(Error)
+    expect(error?.message).toContain('Value must be positive')
+    expect(result).toBeNull()
+    expect(boundaryLogs).toBeNull() // No boundary calls were made due to validation failure
+  })
+
+  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
+      })
+    )
+
+    // Second call should be for run with value 20
+    expect(originalListener).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        input: { value: 20 },
+        output: 40
+      })
+    )
+  })
+
+  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 [error, result, boundaryLogs] = await multiBoundaryTask.safeRun({ values: [1, 2, 3] })
+
+    // Verify success
+    expect(error).toBeNull()
+    expect(result).toEqual({
+      doubled: [2, 4, 6],
+      total: 12
+    })
+
+    // Verify boundary logs for both boundaries
+    expect(boundaryLogs).not.toBeNull()
+    expect(boundaryLogs).toHaveProperty('doubleValue')
+    expect(boundaryLogs).toHaveProperty('sumValues')
+
+    // Check that doubleValue was called 3 times (once for each input value)
+    // @ts-expect-error - we know the boundaryLogs is not null here
+    expect(boundaryLogs.doubleValue).toHaveLength(3)
+
+    // Check that sumValues was called once with the doubled values
+    // @ts-expect-error - we know the boundaryLogs is not null here
+    expect(boundaryLogs.sumValues).toHaveLength(1)
+    // @ts-expect-error - we know the boundaryLogs is not null here
+    expect(boundaryLogs.sumValues[0].input).toEqual([[2, 4, 6]])
+  })
+})