@forgehive/task 0.1.6 → 0.1.8

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

@@ -1,7 +1,7 @@
 import { createTask, Schema } from '../index'
 
 describe('Task safeRun tests', () => {
-  it('returns [null, result, boundaryLogs] on successful execution', async () => {
+  it('returns [result, null, record] on successful execution', async () => {
     // Create a simple schema
     const schema = new Schema({
       value: Schema.number()
@@ -25,16 +25,23 @@ describe('Task safeRun tests', () => {
     )
 
     // Call safeRun with valid input
-    const [error, result, boundaryLogs] = await successTask.safeRun({ value: 5 })
+    const [result, error, record] = 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')
+    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 [error, null, boundaryLogs] on failed execution', async () => {
+  it('returns [null, error, record] on failed execution', async () => {
     // Create a simple schema
     const schema = new Schema({
       value: Schema.number()
@@ -61,17 +68,26 @@ describe('Task safeRun tests', () => {
     )
 
     // Call safeRun with problematic input that will cause an error
-    const [error, result, boundaryLogs] = await errorTask.safeRun({ value: -5 })
+    const [result, error, record] = await errorTask.safeRun({ value: -5 })
 
     // Verify error case
-    expect(error).toBeInstanceOf(Error)
-    expect(error?.message).toContain('Value cannot be negative')
+    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(boundaryLogs).not.toBeNull()
-    expect(boundaryLogs).toHaveProperty('fetchData')
+    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 [error, null, null] on schema validation failure', async () => {
+  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')
@@ -95,13 +111,21 @@ describe('Task safeRun tests', () => {
     )
 
     // Call safeRun with invalid input that will fail schema validation
-    const [error, result, boundaryLogs] = await validationTask.safeRun({ value: 0 })
+    const [result, error, record] = await validationTask.safeRun({ value: 0 })
 
     // Verify validation error case
     expect(error).toBeInstanceOf(Error)
-    expect(error?.message).toContain('Value must be positive')
+    expect(error instanceof Error).toBe(true)
+    if (error instanceof Error) {
+      expect(error.message).toContain('Value must be positive')
+    }
     expect(result).toBeNull()
-    expect(boundaryLogs).toBeNull() // No boundary calls were made due to validation failure
+    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 () => {
@@ -145,7 +169,10 @@ describe('Task safeRun tests', () => {
       1,
       expect.objectContaining({
         input: { value: 10 },
-        output: 20
+        output: 20,
+        boundaries: {
+          fetchData: expect.any(Array)
+        }
       })
     )
 
@@ -154,7 +181,10 @@ describe('Task safeRun tests', () => {
       2,
       expect.objectContaining({
         input: { value: 20 },
-        output: 40
+        output: 40,
+        boundaries: {
+          fetchData: expect.any(Array)
+        }
       })
     )
   })
@@ -187,7 +217,7 @@ describe('Task safeRun tests', () => {
     )
 
     // Call safeRun
-    const [error, result, boundaryLogs] = await multiBoundaryTask.safeRun({ values: [1, 2, 3] })
+    const [result, error, record] = await multiBoundaryTask.safeRun({ values: [1, 2, 3] })
 
     // Verify success
     expect(error).toBeNull()
@@ -196,19 +226,16 @@ describe('Task safeRun tests', () => {
       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]])
+    // 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 })
   })
 })

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