@forgehive/task 0.1.12 → 0.2.0

package/src/index.ts

@@ -35,6 +35,8 @@ export type {
 export { Schema }
 
 export interface TaskConfig<B extends Boundaries = Boundaries> {
+  name?: string
+  description?: string
   schema?: Schema<Record<string, SchemaType>>
   mode?: Mode
   boundaries?: B
@@ -85,11 +87,19 @@ export interface ExecutionRecord<InputType = unknown, OutputType = unknown, B ex
   error?: string
   /** Boundary execution data */
   boundaries: BoundaryLogsFor<B>
+  /** The name of the task (if set) */
+  taskName?: string
+  /** Additional context metadata */
+  metadata?: Record<string, string>
+  /** The type of execution record - computed from output/error state */
+  type: 'success' | 'error' | 'pending'
 }
 
 export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B extends Boundaries = Boundaries> {
   version: string
 
+  getName: () => string | undefined
+  setName: (name: string) => void
   getMode: () => Mode
   setMode: (mode: Mode) => void
   setSchema: (base: Schema<Record<string, SchemaType>>) => void
@@ -119,7 +129,7 @@ export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B ex
   resetMocks: () => void
 
   run: (argv?: Parameters<Func>[0]) => Promise<ReturnType<Func>>
-  safeRun: (argv?: Parameters<Func>[0]) => Promise<[Awaited<ReturnType<Func>> | null, Error | null, ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>]>
+  safeRun: (argv?: Parameters<Func>[0], context?: Record<string, string>) => Promise<[Awaited<ReturnType<Func>> | null, Error | null, ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>]>
 
   // Method for replaying task execution
   safeReplay: (
@@ -146,6 +156,21 @@ export type TaskFunction<S, B extends Boundaries> =
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   (argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<any>;
 
+/**
+ * Utility function to compute the execution record type based on output and error state
+ */
+export function getExecutionRecordType<InputType = unknown, OutputType = unknown, B extends Boundaries = Boundaries>(
+  record: Omit<ExecutionRecord<InputType, OutputType, B>, 'type'>
+): 'success' | 'error' | 'pending' {
+  if (record.error !== undefined && record.error !== null) {
+    return 'error'
+  }
+  if (record.output !== undefined && record.output !== null) {
+    return 'success'
+  }
+  return 'pending'
+}
+
 export const Task = class Task<
   B extends Boundaries = Boundaries,
   Func extends BaseFunction = BaseFunction
@@ -155,6 +180,7 @@ export const Task = class Task<
   _fn: Func
   _mode: Mode
   _coolDown: number
+  _name?: string
   _description?: string
 
   _boundariesDefinition: B
@@ -168,6 +194,8 @@ export const Task = class Task<
   _listener?: ((record: TaskRecord<Parameters<Func>[0], ReturnType<Func>>) => void) | undefined
 
   constructor (fn: Func, conf: TaskConfig<B> = {
+    name: undefined,
+    description: undefined,
     schema: undefined,
     mode: 'proxy',
     boundaries: undefined,
@@ -182,6 +210,10 @@ export const Task = class Task<
     this._mode = conf.mode ?? 'proxy'
     this._boundariesDefinition = conf.boundaries ?? {} as B
 
+    // Set name and description from config
+    this._name = conf.name
+    this._description = conf.description
+
     this._listener = undefined
 
     // Cool down time before killing the process on cli runner
@@ -208,6 +240,14 @@ export const Task = class Task<
     }
   }
 
+  getName(): string | undefined {
+    return this._name
+  }
+
+  setName(name: string): void {
+    this._name = name
+  }
+
   getMode (): Mode {
     return this._mode
   }
@@ -378,10 +418,22 @@ export const Task = class Task<
     Error | null,
     ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>
   ]> {
-    // Initialize log item
-    const logItem: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B> = {
+    // Metadata is empty at start. Then will be populated on the task execution
+    // Need to implement that task have a ctx and setMetadata({key, value}) boundary
+    const metadata = {} as Record<string, string>
+
+    // Initialize log item (without type initially)
+    const logItemBase = {
       input: argv as Parameters<Func>[0],
-      boundaries: {} as BoundaryLogsFor<B>
+      boundaries: {} as BoundaryLogsFor<B>,
+      taskName: this._name,
+      metadata: metadata || {}
+    }
+
+    // Create the log item with computed type
+    const logItem: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B> = {
+      ...logItemBase,
+      type: getExecutionRecordType(logItemBase)
     }
 
     // Create fresh boundaries for this execution
@@ -410,6 +462,7 @@ export const Task = class Task<
           : 'Invalid input'
 
         logItem.error = errorMessage
+        logItem.type = 'error'
         logItem.boundaries = {} as BoundaryLogsFor<B>
 
         // Add boundary elements empty
@@ -433,9 +486,11 @@ export const Task = class Task<
       )
 
       logItem.output = output
+      logItem.type = 'success'
     } catch (caughtError) {
       const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError)
       logItem.error = errorMessage
+      logItem.type = 'error'
       error = new Error(errorMessage)
     }
 
@@ -487,10 +542,18 @@ export const Task = class Task<
     // Extract the input from the execution log
     const argv = executionLog.input
 
-    // Initialize log item for this replay
-    const logItem: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B> = {
+    // Initialize log item for this replay (without type initially)
+    const logItemBase = {
       input: argv,
-      boundaries: {} as BoundaryLogsFor<B>
+      boundaries: {} as BoundaryLogsFor<B>,
+      taskName: this._name,
+      metadata: executionLog.metadata || {}
+    }
+
+    // Create the log item with computed type
+    const logItem: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B> = {
+      ...logItemBase,
+      type: getExecutionRecordType(logItemBase)
     }
 
     // Create boundaries for this replay execution with custom modes based on config
@@ -534,6 +597,7 @@ export const Task = class Task<
           : 'Invalid input'
 
         logItem.error = errorMessage
+        logItem.type = 'error'
         logItem.output = executionLog.output // Keep the original output
 
         // Copy the boundary data from the execution log
@@ -555,9 +619,11 @@ export const Task = class Task<
       )
 
       logItem.output = output
+      logItem.type = 'success'
     } catch (caughtError) {
       const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError)
       logItem.error = errorMessage
+      logItem.type = 'error'
       error = new Error(errorMessage)
     }
 
@@ -602,14 +668,50 @@ export const Task = class Task<
     statusCode: number
     body: string
   }> => {
+    const eventArgs = (event && typeof event === 'object' && 'args' in event) ? (event).args : {}
+
+    // Check validation first
+    if (this._schema) {
+      const validation = this._schema.safeParse(eventArgs)
+      if (!validation.success) {
+        const errorDetails = validation.error?.errors.map(err =>
+          `${err.path.join('.')}: ${err.message}`
+        ).join(', ')
+
+        const errorMessage = errorDetails
+          ? `Invalid input on: ${errorDetails}`
+          : 'Invalid input'
+
+        return {
+          statusCode: 422,
+          body: JSON.stringify({
+            error: errorMessage,
+            details: validation.error?.errors
+          })
+        }
+      }
+    }
+
     try {
       // Call the task's safeRun method
-      const eventArgs = (event && typeof event === 'object' && 'args' in event) ? (event).args : {}
-      const result = await this.safeRun(eventArgs)
+      const [outcome, error, log] = await this.safeRun(eventArgs)
+
+      // Send log to Hive if environment variables are present
+      await this._sendToHive(log)
+
+      if (error) {
+        return {
+          statusCode: 500,
+          body: JSON.stringify({
+            error: error.message,
+            stack: error.stack
+          })
+        }
+      }
 
       return {
         statusCode: 200,
-        body: JSON.stringify(result)
+        body: JSON.stringify(outcome)
       }
     } catch (e: unknown) {
       const error = e as Error
@@ -623,14 +725,124 @@ export const Task = class Task<
       }
     }
   }
+
+  async _sendToHive(log: ExecutionRecord<Parameters<Func>[0], ReturnType<Func>, B>): Promise<void> {
+    const apiKey = process.env.HIVE_API_KEY
+    const apiSecret = process.env.HIVE_API_SECRET
+    const host = process.env.HIVE_HOST
+    const projectName = process.env.HIVE_PROJECT_NAME
+
+
+    // If any required env vars are missing, do nothing
+    if (!apiKey || !apiSecret || !host || !projectName) {
+      // eslint-disable-next-line no-console
+      console.log('Missing required env vars for sending log to Hive:', { apiKey, apiSecret, host, projectName })
+      return
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('Sending log to Hive:', log)
+
+    return new Promise<void>((resolve) => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const https = require('https')
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const http = require('http')
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const url = require('url')
+
+        const logsUrl = `${host}/api/tasks/log-ingest`
+        // eslint-disable-next-line no-console
+        console.log('logsUrl', logsUrl)
+        const parsedUrl = url.parse(logsUrl)
+        const authToken = `${apiKey}:${apiSecret}`
+
+        const postData = JSON.stringify({
+          projectName,
+          taskName: process.env.HIVE_TASK_NAME || this._fn.name || 'unnamed-task',
+          logItem: JSON.stringify(log)
+        })
+
+        const options = {
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port || (parsedUrl.protocol === 'https:' ? 443 : 80),
+          path: parsedUrl.path,
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(postData)
+          }
+        }
+
+        const client = parsedUrl.protocol === 'https:' ? https : http
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const req = client.request(options, (res: any) => {
+          // eslint-disable-next-line no-console
+          console.log('Hive API response status:', res.statusCode)
+          // eslint-disable-next-line no-console
+          console.log('Hive API response headers:', res.headers)
+
+          let responseData = ''
+
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          res.on('data', (chunk: any) => {
+            responseData += chunk
+          })
+
+          res.on('end', () => {
+            // eslint-disable-next-line no-console
+            console.log('Hive API response body:', responseData)
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              // eslint-disable-next-line no-console
+              console.log('Successfully sent log to Hive')
+            } else {
+              // eslint-disable-next-line no-console
+              console.error('Hive API error - Status:', res.statusCode, 'Body:', responseData)
+            }
+            resolve() // Resolve the promise when request completes
+          })
+        })
+
+        req.on('error', (error: Error) => {
+          // eslint-disable-next-line no-console
+          console.error('Failed to send log to Hive - Request error:', error.message)
+          resolve() // Resolve even on error to not block the handler
+        })
+
+        req.write(postData)
+        req.end()
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to send log to Hive:', error instanceof Error ? error.message : 'Unknown error')
+        resolve() // Resolve even on error to not block the handler
+      }
+    })
+  }
+}
+
+/**
+ * Configuration object for creating a task
+ */
+export interface CreateTaskConfig<
+  S extends Schema<Record<string, SchemaType>>,
+  B extends Boundaries,
+  R
+> {
+  name?: string
+  description?: string
+  schema: S
+  boundaries: B
+  fn: (argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<R>
+  mode?: Mode
+  boundariesData?: BoundaryTapeData
 }
 
 /**
  * Helper function to create a task with proper type inference
- * @param schema The schema to validate input against
- * @param boundaries The boundaries to use
- * @param fn The task function
- * @param config Additional task configuration
+ * @param config Configuration object containing schema, boundaries, and function
  * @returns A new Task instance with proper type inference
  */
 export function createTask<
@@ -638,17 +850,18 @@ export function createTask<
   B extends Boundaries,
   R
 >(
-  schema: S,
-  boundaries: B,
-  fn: (argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<R>,
-  config?: Omit<TaskConfig<B>, 'schema' | 'boundaries'>
+  config: CreateTaskConfig<S, B, R>
 ): TaskInstanceType<(argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<R>, B> {
-  return new Task(
-    fn,
+  const task = new Task(
+    config.fn,
     {
-      schema,
-      boundaries,
-      ...config
+      name: config.name,
+      description: config.description,
+      schema: config.schema,
+      boundaries: config.boundaries,
+      mode: config.mode,
+      boundariesData: config.boundariesData
     }
   )
+  return task
 }

package/src/test/add-listener-with-boundaries.test.ts

@@ -17,14 +17,15 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       }
-    )
+    })
 
     task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -58,14 +59,15 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       }
-    )
+    })
 
     task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -109,10 +111,11 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         if (typeof argv.value === 'undefined') {
           throw new Error('Value is required')
@@ -120,7 +123,7 @@ describe('Listener with boundaries tests', () => {
 
         return { ...externalData, ...argv as { value: number } }
       }
-    )
+    })
 
     task.addListener<Record<string, unknown>, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -158,10 +161,11 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         if (typeof argv.value === 'undefined') {
           throw new Error('Value is required')
@@ -169,7 +173,7 @@ describe('Listener with boundaries tests', () => {
 
         return { ...externalData, ...argv as { value: number } }
       }
-    )
+    })
 
     task.addListener<{ value?: number }, { value: number, foo: boolean }>((record) => {
       tape.push(record)
@@ -216,16 +220,17 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         await boundaries.fetchExternalData()
         await boundaries.fetchExternalData()
 
         return { foo: true }
       }
-    )
+    })
 
     task.addListener<{ value: number }, { foo: boolean }>((record) => {
       tape.push(record)
@@ -263,10 +268,11 @@ describe('Listener with boundaries tests', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
+      name: 'task',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         let counter = argv.value
 
         counter = await boundaries.add(counter)
@@ -275,7 +281,7 @@ describe('Listener with boundaries tests', () => {
 
         return counter
       }
-    )
+    })
 
     task.addListener<{ value: number }, number>((record) => {
       tape.push(record)

package/src/test/safe-replay-complex-boundary.test.ts

@@ -1,7 +1,14 @@
 import { Schema } from '@forgehive/schema'
-import { createTask, ExecutionRecord } from '../index'
+import { createTask, ExecutionRecord, getExecutionRecordType } from '../index'
 
 describe('Complex boundary replay tests', () => {
+  // Helper function to create ExecutionRecord with computed type
+  function createExecutionRecord<T, U>(partial: Omit<ExecutionRecord<T, U>, 'type'>): ExecutionRecord<T, U> {
+    return {
+      ...partial,
+      type: getExecutionRecordType(partial)
+    }
+  }
   // Define types for our portfolio data
   type Stock = {
     ticker: string;
@@ -81,10 +88,11 @@ describe('Complex boundary replay tests', () => {
     })
 
     // Create the portfolio value calculation task
-    calculatePortfolioValue = createTask(
+    calculatePortfolioValue = createTask({
+      name: 'calculatePortfolioValue',
       schema,
       boundaries,
-      async ({ userId }, { fetchPortfolio, fetchPrice }) => {
+      fn: async ({ userId }, { fetchPortfolio, fetchPrice }) => {
         // First fetch the portfolio for the user
         const portfolio = await fetchPortfolio(userId)
 
@@ -114,7 +122,7 @@ describe('Complex boundary replay tests', () => {
           stocks: stocksWithValue
         }
       }
-    )
+    })
   })
 
   it('Should calculate portfolio value using multiple boundaries', async () => {
@@ -158,7 +166,7 @@ describe('Complex boundary replay tests', () => {
 
   it('Should replay portfolio calculation from an execution log', async () => {
     // First create a portfolio value calculation execution log
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { userId: 'user1' },
       output: {
         id: 'portfolio1',
@@ -200,7 +208,7 @@ describe('Complex boundary replay tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for all boundaries
     const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
@@ -235,7 +243,7 @@ describe('Complex boundary replay tests', () => {
 
   it('Should handle errors during replay', async () => {
     // Create an execution log with an error in one of the price fetches
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { userId: 'user1' },
       error: 'Price data not available for ticker: GOOGL',
       boundaries: {
@@ -268,7 +276,7 @@ describe('Complex boundary replay tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for all boundaries
     const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(
@@ -303,7 +311,7 @@ describe('Complex boundary replay tests', () => {
     priceData['AAPL'] = 195.00 // Different from replay data
 
     // Create an execution log with historical data
-    const executionLog: ExecutionRecord = {
+    const executionLog: ExecutionRecord = createExecutionRecord({
       input: { userId: 'user1' },
       output: {
         id: 'portfolio1',
@@ -345,7 +353,7 @@ describe('Complex boundary replay tests', () => {
           }
         ]
       }
-    }
+    })
 
     // Use replay mode for portfolio but proxy mode for prices
     const [replayResult, replayError, replayLog] = await calculatePortfolioValue.safeReplay(