@forgehive/task 0.1.0

package/dist/utils/boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.js","sourceRoot":"","sources":["../../src/utils/boundary.ts"],"names":[],"mappings":"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"}

package/jest.config.js

@@ -0,0 +1,9 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/test/**/*.test.ts'],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1'
+  }
+} 

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@forgehive/task",
+  "version": "0.1.0",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "dependencies": {
+      "@forgehive/schema": "^0.1.0"
+    }
+  },
+  "dependencies": {
+    "@forgehive/schema": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.19",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "jest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,344 @@
+import { Schema, type SchemaType, type InferSchema } from '@shadow/schema'
+import { createBoundary, type Mode, type Boundaries, type WrappedBoundaries, type WrappedBoundaryFunction } from './utils/boundary'
+
+export interface Task {
+  id: string;
+  title: string;
+  completed: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type BaseFunction = (...args: any[]) => any
+
+// Re-export the boundary types for external use
+export type { BoundaryFunction, WrappedBoundaryFunction, Boundaries, WrappedBoundaries, Mode } from './utils/boundary'
+
+// Re-export Schema for external use
+export { Schema }
+
+export interface TaskConfig<B extends Boundaries = Boundaries> {
+  schema?: Schema<Record<string, SchemaType>>
+  mode?: Mode
+  boundaries?: B
+  boundariesData?: Record<string, unknown>
+}
+
+/**
+ * Represents the record passed to task listeners
+ */
+export interface TaskRecord<InputType = unknown, OutputType = unknown> {
+  /** The input arguments passed to the task */
+  input: InputType;
+  /** The output returned by the task (if successful) */
+  output?: OutputType;
+  /** The error message if the task failed */
+  error?: string;
+  /** Boundary execution data */
+  boundaries?: Record<string, unknown>;
+}
+
+export interface TaskInstanceType<Func extends BaseFunction = BaseFunction, B extends Boundaries = Boundaries> {
+  getMode: () => Mode
+  setMode: (mode: Mode) => void
+  setSchema: (base: Schema<Record<string, SchemaType>>) => void
+  getSchema: () => Schema<Record<string, SchemaType>> | undefined
+
+  // Validation methos
+  validate: <T extends Record<string, unknown> = Parameters<Func>[0]>(argv?: T) => ReturnType<Schema<Record<string, SchemaType>>['safeParse']> | undefined
+  isValid: <T extends Record<string, unknown> = Parameters<Func>[0]>(argv?: T) => boolean
+
+  // Listener methods
+  addListener: <I = Parameters<Func>[0], O = ReturnType<Func>>(fn: (record: TaskRecord<I, O>) => void) => void
+  removeListener: () => void
+  emit: (data: Partial<TaskRecord>) => void
+
+  // Boundary methods
+  asBoundary: () => (args: Parameters<Func>[0]) => Promise<ReturnType<Func>>
+  getBoundaries: () => WrappedBoundaries<B>
+  setBoundariesData: (boundariesData: Record<string, unknown>) => void
+  getBondariesData: () => Record<string, unknown>
+  getBondariesRunLog: () => Record<string, unknown>
+  startRunLog: () => void
+  run: (argv?: Parameters<Func>[0]) => Promise<ReturnType<Func>>
+}
+
+// Helper type to infer schema type
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type InferSchemaType<S> = S extends Schema<any> ? InferSchema<S> : Record<string, unknown>;
+
+// Helper type for task function with proper typing
+export type TaskFunction<S, B extends Boundaries> =
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<any>;
+
+export const Task = class Task<
+  B extends Boundaries = Boundaries,
+  Func extends BaseFunction = BaseFunction
+> implements TaskInstanceType<Func, B> {
+  _fn: Func
+  _mode: Mode
+  _coolDown: number
+
+  _boundariesDefinition: B
+  _boundaries: WrappedBoundaries<B>
+  _boundariesData: Record<string, unknown> | null
+
+  _schema: Schema<Record<string, SchemaType>> | undefined
+  _listener?: ((record: TaskRecord<Parameters<Func>[0], ReturnType<Func>>) => void) | undefined
+
+  constructor (fn: Func, conf: TaskConfig<B> = {
+    schema: undefined,
+    mode: 'proxy',
+    boundaries: undefined,
+    boundariesData: undefined
+  }) {
+    this._fn = fn
+    this._schema = undefined
+    if (typeof conf.schema !== 'undefined') {
+      this._schema = conf.schema
+    }
+
+    this._mode = conf.mode ?? 'proxy'
+    this._boundariesDefinition = conf.boundaries ?? {} as B
+
+    this._listener = undefined
+
+    // Cool down time before killing the process on cli runner
+    this._coolDown = 1000
+
+    // Review this assignment
+    this._boundariesData = conf.boundariesData ?? null
+    this._boundaries = this._createBounderies({
+      definition: this._boundariesDefinition,
+      baseData: this._boundariesData,
+      mode: this._mode
+    })
+  }
+
+  getMode (): Mode {
+    return this._mode
+  }
+
+  setMode (mode: Mode): void {
+    for (const name in this._boundaries) {
+      const boundary = this._boundaries[name]
+
+      boundary.setMode(mode)
+    }
+
+    this._mode = mode
+  }
+
+  setSchema (schema: Schema<Record<string, SchemaType>>): void {
+    this._schema = schema
+  }
+
+  getSchema (): Schema<Record<string, SchemaType>> | undefined {
+    return this._schema
+  }
+
+  validate<T extends Record<string, unknown> = Parameters<Func>[0]>(argv?: T): ReturnType<Schema<Record<string, SchemaType>>['safeParse']> | undefined {
+    if (typeof this._schema === 'undefined') {
+      return undefined
+    }
+
+    const result = this._schema.safeParse(argv)
+
+    return result
+  }
+
+  isValid<T extends Record<string, unknown> = Parameters<Func>[0]>(argv?: T): boolean {
+    if (typeof this._schema === 'undefined') {
+      return true
+    }
+
+    const result = this._schema.safeParse(argv)
+    return result.success ?? false
+  }
+
+  // Posible improvement to handle multiple listeners, but so far its not needed
+  addListener<I = Parameters<Func>[0], O = ReturnType<Func>>(fn: (record: TaskRecord<I, O>) => void): void {
+    this._listener = fn as (record: TaskRecord<Parameters<Func>[0], ReturnType<Func>>) => void
+  }
+
+  removeListener (): void {
+    this._listener = undefined
+  }
+
+  /*
+    The listener get the input/outout of the call
+    Plus all the boundary data
+  */
+  emit (data: Partial<TaskRecord>): void {
+    if (typeof this._listener === 'undefined') { return }
+
+    const event = {
+      ...data,
+      boundaries: this.getBondariesRunLog()
+    } as TaskRecord<Parameters<Func>[0], ReturnType<Func>>
+
+    this._listener(event)
+  }
+
+  getBoundaries (): WrappedBoundaries<B> {
+    return this._boundaries
+  }
+
+  setBoundariesData (boundariesData: Record<string, unknown>): void {
+    for (const name in this._boundaries) {
+      const boundary = this._boundaries[name]
+
+      let tape
+      if (typeof boundariesData !== 'undefined') {
+        tape = boundariesData[name]
+      }
+
+      if (typeof boundary !== 'undefined' && typeof tape !== 'undefined') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        boundary.setTape(tape as any)
+      }
+    }
+  }
+
+  getBondariesData (): Record<string, unknown> {
+    const boundaries = this._boundaries
+    const boundariesData: Record<string, unknown> = {}
+
+    for (const name in boundaries) {
+      const boundary = boundaries[name]
+
+      boundariesData[name] = boundary.getTape()
+    }
+
+    return boundariesData
+  }
+
+  _createBounderies ({
+    definition,
+    baseData,
+    mode = 'proxy'
+  }: {
+    definition: B;
+    baseData: Record<string, unknown> | null;
+    mode?: Mode;
+  }): WrappedBoundaries<B> {
+    const boundariesFns: Record<string, WrappedBoundaryFunction> = {}
+
+    for (const name in definition) {
+      const boundary = createBoundary(definition[name])
+
+      if (baseData !== null && typeof baseData[name] !== 'undefined') {
+        const tape = baseData[name]
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        boundary.setTape(tape as any)
+      }
+      boundary.setMode(mode as Mode)
+
+      boundariesFns[name] = boundary
+    }
+
+    return boundariesFns as WrappedBoundaries<B>
+  }
+
+  getBondariesRunLog (): Record<string, unknown> {
+    const boundaries = this._boundaries
+    const boundariesRunLog: Record<string, unknown> = {}
+
+    for (const name in boundaries) {
+      const boundary = boundaries[name]
+
+      boundariesRunLog[name] = boundary.getRunData()
+    }
+
+    return boundariesRunLog
+  }
+
+  startRunLog (): void {
+    const boundaries = this._boundaries
+
+    for (const name in boundaries) {
+      const boundary = boundaries[name]
+
+      boundary.startRun()
+    }
+  }
+
+  asBoundary (): (args: Parameters<Func>[0]) => Promise<ReturnType<Func>> {
+    return async (args: Parameters<Func>[0]): Promise<ReturnType<Func>> => {
+      return await this.run(args)
+    }
+  }
+
+  async run (argv?: Parameters<Func>[0]): Promise<ReturnType<Func>> {
+    // start run log
+    this.startRunLog()
+    const boundaries = this._boundaries
+
+    const q = new Promise<ReturnType<Func>>((resolve, reject) => {
+      const isValid = this.isValid(argv)
+
+      if (!isValid) {
+        this.emit({
+          input: argv,
+          error: 'Invalid input'
+        })
+
+        throw new Error('Invalid input')
+      }
+
+      (async (): Promise<ReturnType<Func>> => {
+        // Use proper typing for the function call
+        const output = await this._fn(argv as Parameters<Func>[0], boundaries as unknown as Parameters<Func>[1])
+
+        return output
+      })().then((output) => {
+        this.emit({
+          input: argv,
+          output
+        })
+
+        resolve(output)
+      }).catch((error) => {
+        this.emit({
+          input: argv,
+          error: error.message
+        })
+
+        reject(error)
+      })
+    })
+
+    const result = await q
+
+    return result
+  }
+}
+
+/**
+ * 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
+ * @returns A new Task instance with proper type inference
+ */
+export function createTask<
+  S extends Schema<Record<string, SchemaType>>,
+  B extends Boundaries,
+  R
+>(
+  schema: S,
+  boundaries: B,
+  fn: (argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<R>,
+  config?: Omit<TaskConfig<B>, 'schema' | 'boundaries'>
+): TaskInstanceType<(argv: InferSchemaType<S>, boundaries: WrappedBoundaries<B>) => Promise<R>, B> {
+  return new Task(
+    fn,
+    {
+      schema,
+      boundaries,
+      ...config
+    }
+  )
+}

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

@@ -0,0 +1,299 @@
+import { type TaskRecord, createTask, Schema } from '../index'
+
+describe('Listener with boundaries tests', () => {
+  it('Should record one item and its boundaries tape', async () => {
+    const tape: TaskRecord<{ value: number }, { value: number, foo: boolean }>[] = []
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        const externalData = await boundaries.fetchExternalData()
+        return { ...externalData, ...argv }
+      }
+    )
+
+    task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
+      tape.push(record)
+    })
+
+    await task.run({ value: 5 })
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({ value: 5 })
+    expect(tape[0].output).toEqual({ value: 5, foo: false })
+    expect(tape[0].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } }
+      ]
+    })
+  })
+
+  it('Should record multiple items and their boundaries tape', async () => {
+    const tape: TaskRecord<{ value: number }, { value: number, foo: boolean }>[] = []
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        const externalData = await boundaries.fetchExternalData()
+        return { ...externalData, ...argv }
+      }
+    )
+
+    task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
+      tape.push(record)
+    })
+
+    await task.run({ value: 5 })
+    await task.run({ value: 6 })
+
+    expect(tape.length).toBe(2)
+
+    expect(tape[0].input).toEqual({ value: 5 })
+    expect(tape[0].output).toEqual({ value: 5, foo: false })
+    expect(tape[0].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } }
+      ]
+    })
+
+    expect(tape[1].input).toEqual({ value: 6 })
+    expect(tape[1].output).toEqual({ value: 6, foo: false })
+    expect(tape[1].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } }
+      ]
+    })
+  })
+
+  it('Should record error and its boundaries tape', async () => {
+    const tape: TaskRecord<Record<string, unknown>, { value: number, foo: boolean }>[] = []
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number().optional()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        const externalData = await boundaries.fetchExternalData()
+        if (typeof argv.value === 'undefined') {
+          throw new Error('Value is required')
+        }
+
+        return { ...externalData, ...argv as { value: number } }
+      }
+    )
+
+    task.addListener<Record<string, unknown>, { value: number, foo: boolean }>((record) => {
+      tape.push(record)
+    })
+
+    try {
+      await task.run({})
+    } catch (e) {
+      // Error is expected
+    }
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({})
+    expect(tape[0].error).toBe('Value is required')
+    expect(tape[0].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } }
+      ]
+    })
+  })
+
+  it('Should record error + success and their boundaries tape', async () => {
+    const tape: TaskRecord<{ value?: number }, { value: number, foo: boolean }>[] = []
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number().optional()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        const externalData = await boundaries.fetchExternalData()
+        if (typeof argv.value === 'undefined') {
+          throw new Error('Value is required')
+        }
+
+        return { ...externalData, ...argv as { value: number } }
+      }
+    )
+
+    task.addListener<{ value?: number }, { value: number, foo: boolean }>((record) => {
+      tape.push(record)
+    })
+
+    try {
+      await task.run({})
+    } catch (e) {
+      // Error is expected
+    }
+    await task.run({ value: 5 })
+
+    expect(tape.length).toBe(2)
+    expect(tape[0].input).toEqual({})
+    expect(tape[0].error).toBe('Value is required')
+    expect(tape[0].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } }
+      ]
+    })
+
+    expect(tape[1].input).toEqual({ value: 5 })
+    expect(tape[1].output).toEqual({ value: 5, foo: false })
+    expect(tape[1].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } }
+      ]
+    })
+  })
+
+  it('Should record 2 run logs if boundary called twice', async () => {
+    const tape: TaskRecord<{ value: number }, { foo: boolean }>[] = []
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        await boundaries.fetchExternalData()
+        await boundaries.fetchExternalData()
+
+        return { foo: true }
+      }
+    )
+
+    task.addListener<{ value: number }, { foo: boolean }>((record) => {
+      tape.push(record)
+    })
+
+    await task.run({ value: 5 })
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({ value: 5 })
+    expect(tape[0].output).toEqual({ foo: true })
+    expect(tape[0].boundaries).toEqual({
+      fetchExternalData: [
+        { input: [], output: { foo: false } },
+        { input: [], output: { foo: false } }
+      ]
+    })
+  })
+
+  it('Should record 2 boundary logs', async () => {
+    const tape: TaskRecord<{ value: number }, number>[] = []
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      add: async (value: number): Promise<number> => {
+        return value + 1
+      },
+      subtract: async (value: number): Promise<number> => {
+        return value - 1
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        let counter = argv.value
+
+        counter = await boundaries.add(counter)
+        counter = await boundaries.subtract(counter)
+        counter = await boundaries.subtract(counter)
+
+        return counter
+      }
+    )
+
+    task.addListener<{ value: number }, number>((record) => {
+      tape.push(record)
+    })
+
+    await task.run({ value: 5 })
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({ value: 5 })
+    expect(tape[0].output).toBe(4)
+    expect(tape[0].boundaries).toEqual({
+      add: [
+        { input: [5], output: 6 }
+      ],
+      subtract: [
+        { input: [6], output: 5 },
+        { input: [5], output: 4 }
+      ]
+    })
+  })
+})