@forgehive/record-tape 0.1.6 → 0.2.1

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.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
-    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(`{"input":true,"output":true,"boundaries":{},"type":"success","taskName":"name","metadata":{}}
+{"input":true,"error":"invalid data","boundaries":{},"type":"error","taskName":"name","metadata":{}}
+`)
   })
 
-  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.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
-    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([
+      { input: true, output: true, boundaries: {}, type: 'success', taskName: 'name', metadata: {} },
+      { input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name', metadata: {} }
+    ])
   })
 })

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

@@ -1,345 +1,170 @@
-import { RecordTape, type LogItem } from '../index'
-import { createTask, Schema, type ExecutionRecord, type TaskRecord } from '@forgehive/task'
-
-describe('RecordTape safeRun integration tests', () => {
-  it('should record log items directly from safeRun result', 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
+import { createTask, Schema } from '@forgehive/task'
+import { RecordTape } from '../index'
+
+describe('Safe run', () => {
+  it('Should run a simple task with no boundaries and register to a tape', async () => {
+    const tape = new RecordTape<{ value: number }, { doubled: number }>({})
+
+    const task = createTask({
+      name: 'simple-task',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {},
+      fn: async ({ value }) => {
+        return { doubled: value * 2 }
       }
-    }
-
-    // Create the task
-    const task = createTask(
-      schema,
-      boundaries,
-      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>()
-
-    // Run the task with safeRun and directly use the logItem
-    const [result, error, record] = await task.safeRun({ value: 5 })
-    tape.push('test-task', record)
-
-    // Verify the execution was successful
-    expect(error).toBeNull()
-    expect(result).toEqual({ result: 10, success: true })
-
-    // Get the recorded log from the tape
-    const recordedLog = tape.getLog()
-
-    // Verify the log was recorded correctly
-    expect(recordedLog).toHaveLength(1)
-
-    const logItem = recordedLog[0]
-    expect(logItem.name).toEqual('test-task')
-    expect(logItem.type).toEqual('success')
-    expect(logItem.input).toEqual({ value: 5 })
-    expect(logItem.output).toEqual({ result: 10, success: true })
-    expect(logItem.boundaries).toEqual({
-      fetchData: [{
-        input: [5],
-        output: 10,
-        error: null
-      }]
     })
-  })
-
-  it('should record log items from safeRun successfully', 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 task = createTask(
-      schema,
-      boundaries,
-      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>()
-
-    // Add listener to record the log items
-    task.addListener((record: TaskRecord<{ value: number }, { result: number; success: boolean }>) => {
-      // Manually ensure boundary records have error field for consistency with safeRun
-      if (record.boundaries && record.boundaries.fetchData && Array.isArray(record.boundaries.fetchData)) {
-        record.boundaries.fetchData = record.boundaries.fetchData.map((entry: Record<string, unknown>) => ({
-          ...entry,
-          error: entry.error ?? null,
-          output: entry.output ?? null
-        }))
-      }
 
-      // Cast the record to LogItem type to satisfy TypeScript
-      tape.addLogItem('test-task', record as unknown as LogItem<{ value: number }, { result: number; success: boolean }>)
+    task.addListener((record) => {
+      tape.push(record)
     })
 
-    // Run the task with safeRun
+    // Test simple execution
     const [result, error] = await task.safeRun({ value: 5 })
 
-    // Verify the execution was successful
     expect(error).toBeNull()
-    expect(result).toEqual({ result: 10, success: true })
-
-    // Get the recorded log from the tape
-    const recordedLog = tape.getLog()
+    expect(result).toEqual({ doubled: 10 })
 
-    // Verify the log was recorded correctly
-    expect(recordedLog).toHaveLength(1)
-    expect(recordedLog[0]).toEqual({
-      name: 'test-task',
+    const log = tape.getLog()
+    expect(log).toHaveLength(1)
+    expect(log[0]).toEqual({
       type: 'success',
       input: { value: 5 },
-      output: { result: 10, success: true },
-      boundaries: {
-        fetchData: [{
-          input: [5],
-          output: 10,
-          error: null
-        }]
-      }
+      output: { doubled: 10 },
+      boundaries: {},
+      metadata: {},
+      taskName: 'simple-task'
     })
   })
 
-  it('should record error log items from safeRun', async () => {
-    // Create a schema
-    const schema = new Schema({
-      value: Schema.number()
-    })
+  it('Should run a task with boundaries and register to a tape', async () => {
+    const tape = new RecordTape<{ value: number }, { result: number; success: boolean }>({})
 
-    // 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')
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number().min(10).max(20)
+      }),
+      boundaries: {
+        multiply: async (value: number): Promise<number> => {
+          return value * 2
         }
-        return value * 2
-      }
-    }
-
-    // Create the task
-    const task = createTask(
-      schema,
-      boundaries,
-      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>()
-
-    // Add listener to record the log items
-    task.addListener((record: TaskRecord<{ value: number }, { result: number; success: boolean }>) => {
-      // Manually ensure boundary records have error field for consistency with safeRun
-      if (record.boundaries && record.boundaries.fetchData && Array.isArray(record.boundaries.fetchData)) {
-        record.boundaries.fetchData = record.boundaries.fetchData.map((entry: Record<string, unknown>) => ({
-          ...entry,
-          error: entry.error ?? null,
-          output: entry.output ?? null
-        }))
+      },
+      fn: async ({ value }, { multiply }) => {
+        const result = await multiply(value)
+        return { result, success: result > 10 }
       }
+    })
 
-      // Cast the record to LogItem type to satisfy TypeScript
-      tape.addLogItem('test-task', record as unknown as LogItem<{ value: number }, { result: number; success: boolean }>)
+    task.addListener((record) => {
+      tape.push(record)
     })
 
-    // Run the task with safeRun with a value that will cause an error
-    const [result, error] = await task.safeRun({ value: -5 })
+    // Test invalid input
+    let [result, error] = await task.safeRun({ value: 5 })
 
-    // Verify the execution failed as expected
-    expect(result).toBeNull()
-    expect(error).not.toBeNull()
-    expect(error?.message).toContain('Value cannot be negative')
+    expect(error).toBeDefined()
+    expect(error?.message).toContain('Invalid input')
 
-    // Get the recorded log from the tape
-    const recordedLog = tape.getLog()
+    // Test valid input
+    ;[result, error] = await task.safeRun({ value: 15 })
+    expect(error).toBeNull()
+    expect(result).toEqual({ result: 30, success: true })
 
-    // Verify the error log was recorded correctly
-    expect(recordedLog).toHaveLength(1)
-    expect(recordedLog[0]).toEqual({
-      name: 'test-task',
+    const log = tape.getLog()
+    expect(log).toHaveLength(2)
+    expect(log[0]).toEqual({
       type: 'error',
-      input: { value: -5 },
-      error: 'Value cannot be negative',
+      input: { value: 5 },
+      error: 'Invalid input on: value: Number must be greater than or equal to 10',
       boundaries: {
-        fetchData: [{
-          input: [-5],
-          error: 'Value cannot be negative',
-          output: null
+        multiply: []
+      },
+      metadata: {},
+      taskName: 'test'
+    })
+
+    expect(log[1]).toEqual({
+      type: 'success',
+      input: { value: 15 },
+      output: { result: 30, success: true },
+      boundaries: {
+        multiply: [{
+          input: [15],
+          output: 30
         }]
-      }
+      },
+      metadata: {},
+      taskName: 'test'
     })
   })
 
-  it('should handle error records directly with push', async () => {
-    // Create a schema
-    const schema = new Schema({
-      value: Schema.number()
-    })
+  it('Should run a task with boundaries and register errors to a tape', async () => {
+    const tape = new RecordTape<{ value: number }, { result: 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')
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {
+        divide: async (value: number): Promise<number> => {
+          if (value === 0) {
+            throw new Error('Division by zero')
+          }
+          return 100 / value
         }
-        return value * 2
-      }
-    }
-
-    // Create the task
-    const task = createTask(
-      schema,
-      boundaries,
-      async function ({ value }, { fetchData }) {
-        const result = await fetchData(value)
-        return { result, success: true }
+      },
+      fn: async ({ value }, { divide }) => {
+        const result = await divide(value)
+        return { result }
       }
-    )
-
-    // Create a record tape
-    const tape = new RecordTape<{ value: number }, { result: number; success: boolean }, typeof boundaries>()
+    })
 
-    // Run the task with safeRun with a value that will cause an error
-    const [result, error, record] = await task.safeRun({ value: -5 })
+    task.addListener((record) => {
+      tape.push(record)
+    })
 
-    // Push the error record directly with type parameter
-    tape.push('test-error', record)
+    // Test division by zero
+    const [, error] = await task.safeRun({ value: 0 })
 
-    // Verify the execution failed as expected
-    expect(result).toBeNull()
-    expect(error).not.toBeNull()
-    expect(error instanceof Error).toBe(true)
-    if (error instanceof Error) {
-      expect(error.message).toContain('Value cannot be negative')
-    }
+    expect(error).toBeDefined()
+    expect(error?.message).toBe('Division by zero')
 
-    // Get the recorded log from the tape
-    const recordedLog = tape.getLog()
+    // Test valid input
+    const [secondResult, secondError] = await task.safeRun({ value: 10 })
+    expect(secondError).toBeNull()
+    expect(secondResult).toEqual({ result: 10 })
 
-    // Verify the error log was recorded correctly
-    expect(recordedLog).toHaveLength(1)
-    expect(recordedLog[0]).toEqual({
-      name: 'test-error',
+    const log = tape.getLog()
+    expect(log).toHaveLength(2)
+    expect(log[0]).toEqual({
       type: 'error',
-      input: { value: -5 },
-      error: 'Value cannot be negative',
+      input: { value: 0 },
+      error: 'Division by zero',
       boundaries: {
-        fetchData: [{
-          input: [-5],
-          output: null,
-          error: 'Value cannot be negative'
+        divide: [{
+          input: [0],
+          error: 'Division by zero'
         }]
-      }
+      },
+      metadata: {},
+      taskName: 'test'
     })
-  })
 
-  it('should handle custom execution records with push', async () => {
-    // Create a record tape
-    const tape = new RecordTape<{ value: number }, { result: number }, { fetchData: (n: number) => Promise<number> }>()
-
-    // Create a custom execution record
-    const customRecord: ExecutionRecord<{ value: number }, { result: number }, { fetchData: (n: number) => Promise<number> }> = {
-      input: { value: 10 },
-      output: { result: 20 },
-      boundaries: {
-        fetchData: [
-          {
-            input: [10],
-            output: 20
-          }
-        ]
-      }
-    }
-
-    // Push the custom record
-    tape.push('custom-record', customRecord)
-
-    // Get the recorded log from the tape
-    const recordedLog = tape.getLog()
-
-    // Verify the log was recorded correctly
-    expect(recordedLog).toHaveLength(1)
-    expect(recordedLog[0]).toEqual({
-      name: 'custom-record',
+    expect(log[1]).toEqual({
       type: 'success',
       input: { value: 10 },
-      output: { result: 20 },
+      output: { result: 10 },
       boundaries: {
-        fetchData: [{
+        divide: [{
           input: [10],
-          output: 20,
-          error: null
+          output: 10
         }]
       },
-      context: undefined
-    })
-  })
-
-  it('should handle execution records with Promise outputs correctly', async () => {
-    // Create a record tape
-    const tape = new RecordTape<{ value: number }, { result: number }, { fetchData: (n: number) => Promise<number> }>()
-
-    // Create a custom execution record with a Promise output
-    const promiseResult = Promise.resolve({ result: 30 })
-    const promiseRecord: ExecutionRecord<{ value: number }, Promise<{ result: number }>, { fetchData: (n: number) => Promise<number> }> = {
-      input: { value: 15 },
-      output: promiseResult,
-      boundaries: {
-        fetchData: [
-          {
-            input: [15],
-            output: 30
-          }
-        ]
-      }
-    }
-
-    // Push the record with Promise output using type parameter
-    tape.push('promise-record', promiseRecord)
-
-    // Get the recorded log from the tape
-    const recordedLog = tape.getLog()
-
-    // Verify the log was recorded correctly, with Promise output set to null
-    expect(recordedLog).toHaveLength(1)
-    expect(recordedLog[0]).toEqual({
-      name: 'promise-record',
-      type: 'success',
-      input: { value: 15 },
-      output: null, // Promise output should be set to null
-      boundaries: {
-        fetchData: [{
-          input: [15],
-          output: 30,
-          error: null
-        }]
-      }
+      metadata: {},
+      taskName: 'test'
     })
   })
 })

package/src/tests/save.test.ts

@@ -2,11 +2,11 @@ import fs from 'fs'
 import path from 'path'
 import { RecordTape } from '../index'
 
-const logFileData = '{"name":"name","type":"success","input":[true],"output":true,"boundaries":{}}\n{"name":"name","type":"error","input":[true],"error":"invalid data","boundaries":{}}\n'
+const logFileData = '{"input":true,"output":true,"boundaries":{},"type":"success","taskName":"name","metadata":{}}\n{"input":true,"error":"invalid data","boundaries":{},"type":"error","taskName":"name","metadata":{}}\n'
 
 describe('Save to file async', () => {
   it('Save async to existing file(should add new logs)', async () => {
-    type InputType = boolean[]
+    type InputType = boolean
     type OutputType = boolean
 
     const tapeFilePath = path.resolve(__dirname, './fixtures/save')
@@ -19,8 +19,8 @@ describe('Save to file async', () => {
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
     await tape.load()
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     await tape.save()
 
     const content = await fs.promises.readFile(tapeFilePath + '.log', 'utf8')
@@ -31,20 +31,20 @@ describe('Save to file async', () => {
   })
 
   it('Save async to a path of invalid folder', async () => {
-    type InputType = boolean[]
+    type InputType = boolean
     type OutputType = boolean
 
     const tapeFilePath = path.resolve(__dirname, './nowhere/nop')
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
     await expect(tape.save()).rejects.toThrow('Folder doesn\'t exists')
   })
 
   it('Save async to a log file that doesnt exist', async () => {
-    type InputType = boolean[]
+    type InputType = boolean
     type OutputType = boolean
 
     const tapeFilePath = path.resolve(__dirname, './fixtures/nop')
@@ -56,8 +56,8 @@ describe('Save to file async', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     await tape.save()
 
     const content = await fs.promises.readFile(tapeFilePath + '.log', 'utf8')
@@ -68,7 +68,7 @@ describe('Save to file async', () => {
 
 describe('Save to file sync', () => {
   it('Save sync', () => {
-    type InputType = boolean[]
+    type InputType = boolean
     type OutputType = boolean
 
     const tapeFilePath = path.resolve(__dirname, './fixtures/save')
@@ -80,8 +80,8 @@ describe('Save to file sync', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     tape.saveSync()
 
     const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')
@@ -90,20 +90,20 @@ describe('Save to file sync', () => {
   })
 
   it('Save sync to a path of invalid folder', () => {
-    type InputType = boolean[]
+    type InputType = boolean
     type OutputType = boolean
 
     const tapeFilePath = path.resolve(__dirname, './nowhere/nop')
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
     expect(() => tape.saveSync()).toThrow('Folder doesn\'t exists')
   })
 
   it('Save sync to a log file that doesnt exist', () => {
-    type InputType = boolean[]
+    type InputType = boolean
     type OutputType = boolean
 
     const tapeFilePath = path.resolve(__dirname, './fixtures/nop')
@@ -116,8 +116,8 @@ describe('Save to file sync', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
-    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     tape.saveSync()
 
     const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')