@forgehive/record-tape 0.1.5 → 0.2.0

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 = '{"name":"name","input":true,"output":true,"boundaries":{},"type":"success"}\n{"name":"name","input":true,"error":"invalid data","boundaries":{},"type":"error"}\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.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
     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.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
 
     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.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
     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.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
     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.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
 
     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.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
+    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
     tape.saveSync()
 
     const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')

package/src/tests/task-listener.test.ts

@@ -1,5 +1,5 @@
 import { Task, createTask, Schema } from '@forgehive/task'
-import { RecordTape, LogItem } from '../index'
+import { RecordTape } from '../index'
 
 describe('Task listener', () => {
   it('Should listen to task events', async () => {
@@ -14,17 +14,18 @@ describe('Task listener', () => {
     )
 
     task.addListener<InputType, OutputType>((record) => {
-      const logItem: LogItem<InputType, OutputType> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries }
+      const executionRecord = record.error
+        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
+        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries || {}, type: 'success' as const }
 
-      tape.addLogItem('test', logItem)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tape.push('test', executionRecord as any)
     })
 
     await task.run({})
 
     expect(tape.getLog()).toEqual([
-      { name: 'test', type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {} }
+      { name: 'test', type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {}, metadata: {} }
     ])
   })
 
@@ -42,11 +43,12 @@ describe('Task listener', () => {
     const tape = new RecordTape<{ value: number }, { result: number }>({})
 
     task.addListener<{ value: number }, { result: number }>((record) => {
-      const logItem: LogItem<{ value: number }, { result: number }> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as { result: number }, boundaries: record.boundaries }
+      const executionRecord = record.error
+        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
+        : { input: record.input, output: record.output as { result: number }, boundaries: record.boundaries || {}, type: 'success' as const }
 
-      tape.addLogItem('test', logItem)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tape.push('test', executionRecord as any)
     })
 
     try {
@@ -60,8 +62,8 @@ describe('Task listener', () => {
     const log = tape.getLog()
 
     expect(log).toEqual([
-      { name: 'test', type: 'error', input: { value: 5 }, error: 'Value is not between 10 and 20', boundaries: {} },
-      { name: 'test', type: 'success', input: { value: 15 }, output: { result: 30 }, boundaries: {} }
+      { name: 'test', type: 'error', input: { value: 5 }, error: 'Value is not between 10 and 20', boundaries: {}, metadata: {}, output: undefined },
+      { name: 'test', type: 'success', input: { value: 15 }, output: { result: 30 }, boundaries: {}, metadata: {} }
     ])
   })
 
@@ -79,14 +81,14 @@ describe('Task listener', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async (input, { multiply }) => {
+      fn: async (input, { multiply }) => {
         const result = await multiply(input.value)
         return { result }
       }
-    )
+    })
 
     type InputType = typeof schema
     type OutputType = Awaited<ReturnType<typeof task.run>>
@@ -94,11 +96,12 @@ describe('Task listener', () => {
     const tape = new RecordTape<InputType, OutputType>({})
 
     task.addListener<InputType, OutputType>((record) => {
-      const logItem: LogItem<InputType, OutputType> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries }
+      const executionRecord = record.error
+        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
+        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries || {}, type: 'success' as const }
 
-      tape.addLogItem('test', logItem)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tape.push('test', executionRecord as any)
     })
 
     await task.run({ value: 5 })
@@ -110,8 +113,9 @@ describe('Task listener', () => {
         input: { value: 5 },
         output: { result: 10 },
         boundaries: {
-          multiply: [{ input: [5], output: 10 }]
-        }
+          multiply: [{ input: [5], output: 10, error: null }]
+        },
+        metadata: {}
       }
     ])
   })
@@ -135,21 +139,22 @@ describe('Task listener', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async (input, { multiply }) => {
+      fn: async (input, { multiply }) => {
         const result = await multiply(input.value)
         return { result }
       }
-    )
+    })
 
     task.addListener<InputType, OutputType>((record) => {
-      const logItem: LogItem<InputType, OutputType> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries }
+      const executionRecord = record.error
+        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
+        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries || {}, type: 'success' as const }
 
-      tape.addLogItem('test', logItem)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      tape.push('test', executionRecord as any)
     })
 
     await task.run({ value: 5 })
@@ -161,8 +166,9 @@ describe('Task listener', () => {
         input: { value: 5 },
         output: { result: 10 },
         boundaries: {
-          multiply: [{ input: [5], output: 10 }]
-        }
+          multiply: [{ input: [5], output: 10, error: null }]
+        },
+        metadata: {}
       }
     ])
   })