@forgehive/record-tape 0.1.5 → 0.2.0

package/src/index.ts

@@ -4,30 +4,6 @@ import { type ExecutionRecord, type Boundaries } from '@forgehive/task'
 
 export interface LogRecord<TInput = unknown, TOutput = unknown, B extends Boundaries = Boundaries> extends ExecutionRecord<TInput, TOutput, B> {
   name: string
-  type: 'success' | 'error'
-  context?: Record<string, string>
-}
-
-export interface SuccessLogItem<TInput = unknown, TOutput = unknown> {
-  input: TInput
-  output: TOutput
-  boundaries?: Record<string, unknown>
-}
-
-export interface ErrorLogItem<TInput = unknown> {
-  input: TInput
-  error: unknown
-  boundaries?: Record<string, unknown>
-}
-
-export type LogItem<TInput = unknown, TOutput = unknown> = SuccessLogItem<TInput, TOutput> | ErrorLogItem<TInput>
-
-// Additional type to handle TaskRecord compatibility
-export type TaskLogItem<TInput = unknown, TOutput = unknown> = LogItem<TInput, TOutput> | {
-  input: TInput;
-  output?: TOutput;
-  error?: unknown;
-  boundaries?: Record<string, unknown>;
 }
 
 interface Config<TInput = unknown, TOutput = unknown, B extends Boundaries = Boundaries> {
@@ -62,65 +38,35 @@ export class RecordTape<TInput = unknown, TOutput = unknown, B extends Boundarie
     this._mode = mode
   }
 
-  addLogItem(name: string, logItem: LogItem<TInput, TOutput>): void {
+  addExecutionRecord(name: string, record: ExecutionRecord<TInput, TOutput, B>): void {
     if (this._mode === 'replay') {
       return
     }
 
-    // Format boundaries to ensure both error and output fields are set if needed
+    // Format boundaries to ensure consistent structure
     const formattedBoundaries: Record<string, unknown> = {}
-    if (logItem.boundaries) {
-      for (const key in logItem.boundaries) {
-        // Check if the source is from safe-run (if it has error field in entries)
-        const boundaryEntries = logItem.boundaries[key] as Array<Record<string, unknown>>
-        const isSafeRun = boundaryEntries.some(entry => entry.error !== undefined)
-
-        formattedBoundaries[key] = boundaryEntries.map(entry => {
-          // Only add error field if it's from safe-run
-          return isSafeRun ?
-            {
-              input: entry.input,
-              output: entry.output ?? null,
-              error: entry.error ?? null
-            } :
-            {
-              input: entry.input,
-              output: entry.output
-            }
-        })
+    if (record.boundaries) {
+      for (const key in record.boundaries) {
+        const boundaryEntries = record.boundaries[key] as Array<Record<string, unknown>>
+        formattedBoundaries[key] = boundaryEntries.map(entry => ({
+          input: entry.input,
+          output: entry.output ?? null,
+          error: entry.error ?? null
+        }))
       }
     }
 
-    // Handle LogItem interface - need to type cast to access properties safely
-    const typedLogItem = logItem as (SuccessLogItem<TInput, TOutput> | ErrorLogItem<TInput>)
-
-    if ('output' in typedLogItem && typedLogItem.output !== undefined) {
-      const { input, output } = typedLogItem
-      this._log.push({
-        name,
-        type: 'success',
-        input,
-        output,
-        boundaries: formattedBoundaries
-      } as LogRecord<TInput, TOutput, B>)
-    } else if ('error' in typedLogItem && typedLogItem.error !== undefined) {
-      const { input, error } = typedLogItem
-      this._log.push({
-        name,
-        type: 'error',
-        input,
-        error,
-        boundaries: formattedBoundaries
-      } as LogRecord<TInput, TOutput, B>)
-    } else {
-      throw new Error('invalid log item')
-    }
+    this._log.push({
+      name,
+      ...record,
+      boundaries: formattedBoundaries
+    } as LogRecord<TInput, TOutput, B>)
   }
 
   push(
     name: string,
     record: ExecutionRecord<TInput, unknown, B>,
-    context?: Record<string, string>
+    metadata?: Record<string, string>
   ): LogRecord<TInput, TOutput, B> {
     if (this._mode === 'replay') {
       return {} as LogRecord<TInput, TOutput, B>
@@ -141,43 +87,35 @@ export class RecordTape<TInput = unknown, TOutput = unknown, B extends Boundarie
       }
     }
 
-    let logRecord: LogRecord<TInput, TOutput, B>
-
-    if ('output' in record && record.output !== undefined) {
-      const input = record.input
-      // Handle Promise outputs by setting to null in the log
-      const output = record.output instanceof Promise ? null : record.output
-
-      logRecord = {
-        name,
-        type: 'success',
-        input,
-        output,
-        boundaries: formattedBoundaries,
-        context
-      } as LogRecord<TInput, TOutput, B>
-      this._log.push(logRecord)
-    } else if ('error' in record && record.error !== undefined) {
-      const input = record.input
-      const error = record.error
-
-      logRecord = {
-        name,
-        type: 'error',
-        input,
-        error,
-        boundaries: formattedBoundaries,
-        context
-      } as LogRecord<TInput, TOutput, B>
-      this._log.push(logRecord)
-    } else {
-      throw new Error('invalid record type')
-    }
+    // Use the type from ExecutionRecord if available, otherwise derive it
+    const recordType = ('type' in record && record.type) ? record.type :
+      (record.output !== undefined && record.output !== null) ? 'success' :
+        (record.error !== undefined) ? 'error' : 'pending'
+
+    // Handle Promise outputs by setting to null in the log
+    const output = record.output instanceof Promise ? null : record.output
+
+    // Merge metadata from record and parameter (parameter takes precedence)
+    const mergedMetadata = { ...record.metadata, ...metadata }
+
+    const logRecord = {
+      name,
+      ...record,
+      type: recordType,
+      output,
+      boundaries: formattedBoundaries,
+      metadata: mergedMetadata
+    } as LogRecord<TInput, TOutput, B>
+
+    this._log.push(logRecord)
 
     return logRecord
   }
 
   addLogRecord(logRecord: LogRecord<TInput, TOutput, B>): void {
+    if (this._mode === 'replay') {
+      return
+    }
     this._log.push(logRecord)
   }
 
@@ -219,11 +157,11 @@ export class RecordTape<TInput = unknown, TOutput = unknown, B extends Boundarie
   }
 
   recordFrom(name: string, task: { _listener?: unknown; setBoundariesData: (data: Record<string, unknown>) => void }): void {
-    // Add listner
-    task._listener = async (logItem: LogItem<TInput, TOutput>, _boundaries: Record<string, unknown>): Promise<void> => {
+    // Add listener for ExecutionRecord
+    task._listener = async (executionRecord: ExecutionRecord<TInput, TOutput, B>, _boundaries: Record<string, unknown>): Promise<void> => {
       // Only update if mode is record
       if (this.getMode() === 'record') {
-        this.addLogItem(name, logItem)
+        this.addExecutionRecord(name, executionRecord)
       }
     }
 

package/src/tests/index.test.ts

@@ -59,8 +59,8 @@ describe('Base tests', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: emptyPath })
-    tape.addLogItem('test', { input: [{name: 'test'}], output: { age: 1 } })
-    tape.addLogItem('test', { input: [{name: 'test'}], error: new Error('test') })
+    tape.addLogRecord({ name: 'test', input: [{name: 'test'}], output: { age: 1 }, type: 'success', boundaries: {} })
+    tape.addLogRecord({ name: 'test', input: [{name: 'test'}], error: 'test', type: 'error', boundaries: {} })
 
     const data = tape.getLog()
     expect(data.length).toBe(2)
@@ -82,7 +82,7 @@ describe('Base tests', () => {
 
     expect(input2).toEqual([{name: 'test'}])
     expect(output2).toBeUndefined()
-    expect(error2).toEqual(new Error('test'))
+    expect(error2).toEqual('test')
     expect(type2).toBe('error')
   })
 })

package/src/tests/log-format.test.ts

@@ -1,48 +1,36 @@
 import { RecordTape } from '../index'
 
-const baseTapeData = [
-  {
-    name: 'name',
-    type: 'success',
-    input: [true],
-    output: true,
-    boundaries: {}
-  },
-  {
-    name: 'name',
-    type: 'error',
-    input: [true],
-    error: 'invalid data',
-    boundaries: {}
-  }
-]
-
-const logFileData = '{"name":"name","type":"success","input":[true],"output":true,"boundaries":{}}\n{"name":"name","type":"error","input":[true],"error":"invalid data","boundaries":{}}\n'
-
-describe('Log format', () => {
-  it('Should ensure format', () => {
-    type InputType = boolean[]
+describe('Test log item formating', () => {
+  it('Should format a log items into valid JSON', async () => {
+    type InputType = boolean
     type OutputType = boolean
 
     const tape = new RecordTape<InputType, OutputType>({})
+    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
 
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    const str = tape.stringify()
 
-    expect(tape.getLog()).toEqual(baseTapeData)
+    expect(str).toEqual(`{"name":"name","input":true,"output":true,"boundaries":{},"type":"success"}
+{"name":"name","input":true,"error":"invalid data","boundaries":{},"type":"error"}
+`)
   })
 
-  it('Should serialize to one line per item', () => {
-    type InputType = boolean[]
+  it('Should parse the string to a list of records', async () => {
+    type InputType = boolean
     type OutputType = boolean
 
     const tape = new RecordTape<InputType, OutputType>({})
+    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
 
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    const str = tape.stringify()
+    const tape2 = new RecordTape<InputType, OutputType>({})
+    const records = tape2.parse(str)
 
-    const logFile = tape.stringify()
-
-    expect(logFile).toBe(logFileData)
+    expect(records).toEqual([
+      { name: 'name', input: true, output: true, boundaries: {}, type: 'success' },
+      { name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' }
+    ])
   })
 })

package/src/tests/mode.test.ts

@@ -1,92 +1,105 @@
 import { RecordTape } from '../index'
 
-describe('Mode behavior', () => {
-  it('Should start in record mode by default', () => {
-    const tape = new RecordTape()
-    expect(tape.getMode()).toBe('record')
-  })
-
-  it('Should not add log items in replay mode', () => {
-    type InputType = { value: number }
-    type OutputType = { result: number }
+describe('Test mode', () => {
+  it('Should record items if mode is record', () => {
+    type InputType = { name: string }
+    type OutputType = { age: number }
 
-    const tape = new RecordTape<InputType, OutputType>()
-    tape.setMode('replay')
+    const tape = new RecordTape<InputType, OutputType>({})
+    tape.setMode('record')
 
-    tape.addLogItem('test', {
-      input: { value: 1 },
-      output: { result: 2 }
+    tape.addLogRecord({
+      name: 'test',
+      input: { name: 'test' },
+      output: { age: 1 },
+      boundaries: {},
+      type: 'success'
     })
 
-    expect(tape.getLog()).toEqual([])
+    const data = tape.getLog()
+
+    expect(data).toEqual([{
+      name: 'test',
+      input: { name: 'test' },
+      output: { age: 1 },
+      boundaries: {},
+      type: 'success'
+    }])
   })
 
-  it('Should add log items in record mode', () => {
-    type InputType = { value: number }
-    type OutputType = { result: number }
+  it('Should not record items if mode is replay', () => {
+    type InputType = { name: string }
+    type OutputType = { age: number }
 
-    const tape = new RecordTape<InputType, OutputType>()
-    tape.setMode('record')
+    const tape = new RecordTape<InputType, OutputType>({})
+    tape.setMode('replay')
 
-    tape.addLogItem('test', {
-      input: { value: 1 },
-      output: { result: 2 }
+    tape.addLogRecord({
+      name: 'test',
+      input: { name: 'test' },
+      output: { age: 1 },
+      boundaries: {},
+      type: 'success'
     })
 
-    expect(tape.getLog()).toEqual([
-      {
-        name: 'test',
-        type: 'success',
-        input: { value: 1 },
-        output: { result: 2 },
-        boundaries: {}
-      }
-    ])
+    const data = tape.getLog()
+    expect(data).toEqual([])
   })
 
-  it('Should switch between modes', () => {
-    type InputType = { value: number }
-    type OutputType = { result: number }
+  it('Should append logs with same name', () => {
+    type InputType = { name: string }
+    type OutputType = { age: number }
 
-    const tape = new RecordTape<InputType, OutputType>()
+    const tape = new RecordTape<InputType, OutputType>({})
+    tape.setMode('record')
 
-    // Start in record mode
-    expect(tape.getMode()).toBe('record')
-    tape.addLogItem('test1', {
-      input: { value: 1 },
-      output: { result: 2 }
+    tape.addLogRecord({
+      name: 'test1',
+      input: { name: 'test' },
+      output: { age: 1 },
+      boundaries: {},
+      type: 'success'
     })
 
-    // Switch to replay mode
-    tape.setMode('replay')
-    expect(tape.getMode()).toBe('replay')
-    tape.addLogItem('test2', {
-      input: { value: 3 },
-      output: { result: 4 }
+    tape.addLogRecord({
+      name: 'test2',
+      input: { name: 'test' },
+      output: { age: 2 },
+      boundaries: {},
+      type: 'success'
     })
 
-    // Switch back to record mode
-    tape.setMode('record')
-    expect(tape.getMode()).toBe('record')
-    tape.addLogItem('test3', {
-      input: { value: 5 },
-      output: { result: 6 }
+    tape.addLogRecord({
+      name: 'test3',
+      input: { name: 'test' },
+      output: { age: 3 },
+      boundaries: {},
+      type: 'success'
     })
 
-    expect(tape.getLog()).toEqual([
+    const data = tape.getLog()
+
+    expect(data).toEqual([
       {
         name: 'test1',
-        type: 'success',
-        input: { value: 1 },
-        output: { result: 2 },
-        boundaries: {}
+        input: { name: 'test' },
+        output: { age: 1 },
+        boundaries: {},
+        type: 'success'
+      },
+      {
+        name: 'test2',
+        input: { name: 'test' },
+        output: { age: 2 },
+        boundaries: {},
+        type: 'success'
       },
       {
         name: 'test3',
-        type: 'success',
-        input: { value: 5 },
-        output: { result: 6 },
-        boundaries: {}
+        input: { name: 'test' },
+        output: { age: 3 },
+        boundaries: {},
+        type: 'success'
       }
     ])
   })

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

@@ -1,4 +1,4 @@
-import { RecordTape, type LogItem } from '../index'
+import { RecordTape } from '../index'
 import { createTask, Schema, type ExecutionRecord, type TaskRecord } from '@forgehive/task'
 
 describe('RecordTape safeRun integration tests', () => {
@@ -16,14 +16,14 @@ describe('RecordTape safeRun integration tests', () => {
     }
 
     // Create the task
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Create a record tape
     const tape = new RecordTape<{ value: number }, { result: number; success: boolean }, typeof boundaries>()
@@ -70,14 +70,14 @@ describe('RecordTape safeRun integration tests', () => {
     }
 
     // Create the task
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Create a record tape
     const tape = new RecordTape<{ value: number }, { result: number; success: boolean }, typeof boundaries>()
@@ -93,8 +93,9 @@ describe('RecordTape safeRun integration tests', () => {
         }))
       }
 
-      // Cast the record to LogItem type to satisfy TypeScript
-      tape.addLogItem('test-task', record as unknown as LogItem<{ value: number }, { result: number; success: boolean }>)
+      // Add the record using push method
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tape.push('test-task', record as any)
     })
 
     // Run the task with safeRun
@@ -120,7 +121,9 @@ describe('RecordTape safeRun integration tests', () => {
           output: 10,
           error: null
         }]
-      }
+      },
+      metadata: {},
+      taskName: undefined
     })
   })
 
@@ -141,14 +144,14 @@ describe('RecordTape safeRun integration tests', () => {
     }
 
     // Create the task
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Create a record tape
     const tape = new RecordTape<{ value: number }, { result: number; success: boolean }, typeof boundaries>()
@@ -164,8 +167,9 @@ describe('RecordTape safeRun integration tests', () => {
         }))
       }
 
-      // Cast the record to LogItem type to satisfy TypeScript
-      tape.addLogItem('test-task', record as unknown as LogItem<{ value: number }, { result: number; success: boolean }>)
+      // Add the record using push method
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tape.push('test-task', record as any)
     })
 
     // Run the task with safeRun with a value that will cause an error
@@ -192,7 +196,10 @@ describe('RecordTape safeRun integration tests', () => {
           error: 'Value cannot be negative',
           output: null
         }]
-      }
+      },
+      metadata: {},
+      output: undefined,
+      taskName: undefined
     })
   })
 
@@ -213,14 +220,14 @@ describe('RecordTape safeRun integration tests', () => {
     }
 
     // Create the task
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async function ({ value }, { fetchData }) {
+      fn: async function ({ value }, { fetchData }) {
         const result = await fetchData(value)
         return { result, success: true }
       }
-    )
+    })
 
     // Create a record tape
     const tape = new RecordTape<{ value: number }, { result: number; success: boolean }, typeof boundaries>()
@@ -255,7 +262,10 @@ describe('RecordTape safeRun integration tests', () => {
           output: null,
           error: 'Value cannot be negative'
         }]
-      }
+      },
+      metadata: {},
+      output: undefined,
+      taskName: undefined
     })
   })
 
@@ -267,6 +277,7 @@ describe('RecordTape safeRun integration tests', () => {
     const customRecord: ExecutionRecord<{ value: number }, { result: number }, { fetchData: (n: number) => Promise<number> }> = {
       input: { value: 10 },
       output: { result: 20 },
+      type: 'success',
       boundaries: {
         fetchData: [
           {
@@ -297,7 +308,7 @@ describe('RecordTape safeRun integration tests', () => {
           error: null
         }]
       },
-      context: undefined
+      metadata: {}
     })
   })
 
@@ -310,6 +321,7 @@ describe('RecordTape safeRun integration tests', () => {
     const promiseRecord: ExecutionRecord<{ value: number }, Promise<{ result: number }>, { fetchData: (n: number) => Promise<number> }> = {
       input: { value: 15 },
       output: promiseResult,
+      type: 'success',
       boundaries: {
         fetchData: [
           {
@@ -339,7 +351,8 @@ describe('RecordTape safeRun integration tests', () => {
           output: 30,
           error: null
         }]
-      }
+      },
+      metadata: {}
     })
   })
 })