@forgehive/record-tape 0.2.0 → 0.2.2

package/src/tests/data-methods.test.ts

@@ -0,0 +1,150 @@
+import { RecordTape } from '../index'
+
+describe('RecordTape Data Methods', () => {
+  let tape: RecordTape
+
+  beforeEach(() => {
+    tape = new RecordTape()
+  })
+
+  describe('getLength', () => {
+    test('should return 0 for empty tape', () => {
+      expect(tape.getLength()).toBe(0)
+    })
+
+    test('should return correct length after adding records', () => {
+      const record1 = {
+        input: { userId: 1 },
+        output: { name: 'John' },
+        taskName: 'getUser',
+        boundaries: {},
+        type: 'success' as const
+      }
+
+      const record2 = {
+        input: { userId: 2 },
+        output: { name: 'Jane' },
+        taskName: 'getUser',
+        boundaries: {},
+        type: 'success' as const
+      }
+
+      tape.push(record1)
+      expect(tape.getLength()).toBe(1)
+
+      tape.push(record2)
+      expect(tape.getLength()).toBe(2)
+    })
+
+    test('should return correct length after removing records', () => {
+      const record = {
+        input: { userId: 1 },
+        output: { name: 'John' },
+        taskName: 'getUser',
+        boundaries: {},
+        type: 'success' as const
+      }
+
+      tape.push(record)
+      tape.push(record)
+      expect(tape.getLength()).toBe(2)
+
+      tape.shift()
+      expect(tape.getLength()).toBe(1)
+
+      tape.shift()
+      expect(tape.getLength()).toBe(0)
+    })
+  })
+
+  describe('shift', () => {
+    test('should return undefined for empty tape', () => {
+      expect(tape.shift()).toBeUndefined()
+    })
+
+    test('should return and remove first record', () => {
+      const record1 = {
+        input: { userId: 1 },
+        output: { name: 'John' },
+        taskName: 'getUser',
+        boundaries: {},
+        type: 'success' as const
+      }
+
+      const record2 = {
+        input: { userId: 2 },
+        output: { name: 'Jane' },
+        taskName: 'getUser',
+        boundaries: {},
+        type: 'success' as const
+      }
+
+      tape.push(record1)
+      tape.push(record2)
+
+      const shiftedRecord = tape.shift()
+
+      // Should return the first record
+      expect(shiftedRecord).toEqual(expect.objectContaining({
+        taskName: 'getUser',
+        input: { userId: 1 },
+        output: { name: 'John' },
+        type: 'success'
+      }))
+
+      // Should have removed the first record
+      expect(tape.getLength()).toBe(1)
+      expect(tape.getLog()[0]).toEqual(expect.objectContaining({
+        taskName: 'getUser',
+        input: { userId: 2 },
+        output: { name: 'Jane' },
+        type: 'success'
+      }))
+    })
+
+    test('should work correctly with multiple shifts', () => {
+      const records = [
+        {
+          input: { userId: 1 },
+          output: { name: 'John' },
+          taskName: 'getUser',
+          boundaries: {},
+          type: 'success' as const
+        },
+        {
+          input: { userId: 2 },
+          output: { name: 'Jane' },
+          taskName: 'getUser',
+          boundaries: {},
+          type: 'success' as const
+        },
+        {
+          input: { userId: 3 },
+          output: { name: 'Bob' },
+          taskName: 'getUser',
+          boundaries: {},
+          type: 'success' as const
+        }
+      ]
+
+      records.forEach(record => tape.push(record))
+      expect(tape.getLength()).toBe(3)
+
+      const first = tape.shift()
+      expect(first?.input).toEqual({ userId: 1 })
+      expect(tape.getLength()).toBe(2)
+
+      const second = tape.shift()
+      expect(second?.input).toEqual({ userId: 2 })
+      expect(tape.getLength()).toBe(1)
+
+      const third = tape.shift()
+      expect(third?.input).toEqual({ userId: 3 })
+      expect(tape.getLength()).toBe(0)
+
+      const fourth = tape.shift()
+      expect(fourth).toBeUndefined()
+      expect(tape.getLength()).toBe(0)
+    })
+  })
+})

package/src/tests/index.test.ts

@@ -53,14 +53,9 @@ describe('Base tests', () => {
   })
 
   it('Should create a new tape with generic types', () => {
-    type InputType = [{ name: string }]
-    type OutputType = {
-      age: number
-    }
-
-    const tape = new RecordTape<InputType, OutputType>({ path: emptyPath })
-    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 tape = new RecordTape({ path: emptyPath })
+    tape.push({ input: [{name: 'test'}], output: { age: 1 }, type: 'success', boundaries: {}, taskName: 'test' })
+    tape.push({ input: [{name: 'test'}], error: 'test', type: 'error', boundaries: {}, taskName: 'test' })
 
     const data = tape.getLog()
     expect(data.length).toBe(2)

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

@@ -6,13 +6,13 @@ describe('Test log item formating', () => {
     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.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
     const str = tape.stringify()
 
-    expect(str).toEqual(`{"name":"name","input":true,"output":true,"boundaries":{},"type":"success"}
-{"name":"name","input":true,"error":"invalid data","boundaries":{},"type":"error"}
+    expect(str).toEqual(`{"input":true,"output":true,"boundaries":{},"type":"success","taskName":"name","metadata":{}}
+{"input":true,"error":"invalid data","boundaries":{},"type":"error","taskName":"name","metadata":{}}
 `)
   })
 
@@ -21,16 +21,16 @@ describe('Test log item formating', () => {
     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.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
     const str = tape.stringify()
     const tape2 = new RecordTape<InputType, OutputType>({})
     const records = tape2.parse(str)
 
     expect(records).toEqual([
-      { name: 'name', input: true, output: true, boundaries: {}, type: 'success' },
-      { name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' }
+      { 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,358 +1,170 @@
+import { createTask, Schema } from '@forgehive/task'
 import { RecordTape } 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
-      }
-    }
+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 }>({})
 
-    // Create the task
     const task = createTask({
-      schema,
-      boundaries,
-      fn: async function ({ value }, { fetchData }) {
-        const result = await fetchData(value)
-        return { result, success: true }
+      name: 'simple-task',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {},
+      fn: async ({ value }) => {
+        return { doubled: value * 2 }
       }
     })
 
-    // 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()
+    task.addListener((record) => {
+      tape.push(record)
     })
 
-    // Define the boundaries
-    const boundaries = {
-      fetchData: async (value: number): Promise<number> => {
-        return value * 2
-      }
-    }
-
-    // Create the task
-    const task = createTask({
-      schema,
-      boundaries,
-      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>()
-
-    // 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
-        }))
-      }
-
-      // 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
+    // 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: undefined
+      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')
-        }
-        return value * 2
-      }
-    }
-
-    // Create the task
     const task = createTask({
-      schema,
-      boundaries,
-      fn: async function ({ value }, { fetchData }) {
-        const result = await fetchData(value)
-        return { result, success: true }
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number().min(10).max(20)
+      }),
+      boundaries: {
+        multiply: async (value: number): Promise<number> => {
+          return value * 2
+        }
+      },
+      fn: async ({ value }, { multiply }) => {
+        const result = await multiply(value)
+        return { result, success: result > 10 }
       }
     })
 
-    // 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
-        }))
-      }
-
-      // Add the record using push method
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      tape.push('test-task', record as any)
+    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: {},
-      output: undefined,
-      taskName: undefined
+      taskName: 'test'
     })
-  })
 
-  it('should handle error records directly with push', async () => {
-    // Create a schema
-    const schema = new Schema({
-      value: Schema.number()
+    expect(log[1]).toEqual({
+      type: 'success',
+      input: { value: 15 },
+      output: { result: 30, success: true },
+      boundaries: {
+        multiply: [{
+          input: [15],
+          output: 30
+        }]
+      },
+      metadata: {},
+      taskName: 'test'
     })
+  })
 
-    // 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
-      }
-    }
+  it('Should run a task with boundaries and register errors to a tape', async () => {
+    const tape = new RecordTape<{ value: number }, { result: number }>({})
 
-    // Create the task
     const task = createTask({
-      schema,
-      boundaries,
-      fn: async function ({ value }, { fetchData }) {
-        const result = await fetchData(value)
-        return { result, success: true }
+      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
+        }
+      },
+      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: {},
-      output: undefined,
-      taskName: undefined
+      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 },
-      type: 'success',
-      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
         }]
       },
-      metadata: {}
-    })
-  })
-
-  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,
-      type: 'success',
-      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: {}
+      metadata: {},
+      taskName: 'test'
     })
   })
 })