Agent.js

import { EventEmitter } from "events";
import { StateController } from "./StateController.js";

/**
 * Agent class
 * @extends EventEmitter
 * @description Agent class is a base class for all agents.
 */
export default class Agent extends EventEmitter {
  #id = null;
  #name = null;
  #owner = null;
  hooks = {};
  state = new StateController();
  #excludedErrors = [];
  constructor() {
    super();
  }

  getId() {
    return this.#id;
  }

  getName() {
    return this.#name;
  }

  getOwner() {
    return this.#owner;
  }

  setId(id) {
    this.#id = id;
  }

  setName(name) {
    this.#name = name;
  }

  setOwner(owner) {
    this.#owner = owner;
  }

  getState() {
    return this.state.getState();
  }

  setState(state) {
    this.state.setState(state);
  }

  #__beforeAny(name, destroy = false) {
    if (!Object.hasOwn(this.hooks, name)) {
      this.hooks[name] = {
        before: [],
        execute: async function(...args) {},
        after: [],
        destroy,
        errors: [],
      };
    }
  }

  /**
   * On before hook
   * @param {string} name - The name of the hook
   * @param {Function} cb - The callback function
   * @param {boolean} destroy - Whether to destroy the hook after execution
   * @returns {Agent} The agent instance
   */
  onBefore(name, cb, destroy = false) {
    this.#__beforeAny(name, destroy);
    this.hooks[name].before.push(cb.bind(this));
    return this;
  }

  /**
   * On execute hook
   * @param {string} name - The name of the hook
   * @param {Function} cb - The callback function
   * @param {boolean} destroy - Whether to destroy the hook after execution
   * @returns {Agent} The agent instance
   */
  onExecute(name, cb, destroy = false) {
    this.#__beforeAny(name, destroy);
    this.hooks[name].execute = cb.bind(this);
    return this;
  }

  /**
   * On after hook
   * @param {string} name - The name of the hook
   * @param {Function} cb - The callback function
   * @param {boolean} destroy - Whether to destroy the hook after execution
   * @returns {Agent} The agent instance
   */
  onAfter(name, cb, destroy = false) {
    this.#__beforeAny(name, destroy);
    this.hooks[name].after.push(cb.bind(this));
    return this;
  }

  /**
   * Get errors
   * @param {string} name - The name of the hook
   * @returns {Array} The errors
   */
  getErrors(name) {
    return this.hooks[name].errors;
  }

  /**
   * Has errors
   * @param {string} name - The name of the hook
   * @returns {boolean} Whether the hook has errors
   */
  hasErrors(name) {
    return this.hooks[name].errors.length > 0;
  }

  /**
   * Clear errors
   * @param {string} name - The name of the hook
   */
  clearErrors(name) {
    this.hooks[name].errors = [];
  }

  /**
   * Run a hook
   * @param {string} name - The name of the hook
   * @param {Array} args - The arguments to pass to the hook
   */
  async run(name, ...args) {
    const __runBefore = async (name, ...args) => {
      // console.log("Running before", name, args);
      if (this.hooks[name].before.length > 0) {
        for (const cb of this.hooks[name].before) {
          try {
            await cb(...args);
          } catch (error) {
            this.hooks[name].errors.push(error);
            if (this.isExcludedError(error)) {
              continue;
            } else {
              throw error;
            }
          }
        }
      }
      return;
    };
    const __runAfter = async (name, ...args) => {
      if (this.hooks[name].after.length > 0) {
        for (const cb of this.hooks[name].after) {
          try {
            await cb(...args);
          } catch (error) {
            this.hooks[name].errors.push(error);
            if (this.isExcludedError(error)) {
              continue;
            } else {
              throw error;
            }
          }
        }
      }
      if (this.hooks[name].destroy) {
        delete this.hooks[name];
      }
      return;
    };
    const __runExecute = async (name, ...args) => {
      if (this.hooks[name].execute) {
        try {
          await this.hooks[name].execute(...args);
        } catch (error) {
          this.hooks[name].errors.push(error);
          if (!this.isExcludedError(error)) {
            throw error;
          }
        }
      }
      return;
    };
    await __runBefore(name, ...args);
    await __runExecute(name, ...args);
    await __runAfter(name, ...args);
  }

  /**
   * Get excluded errors
   * @returns {Array} The excluded errors
   */
  getExcludedErrors() {
    return this.#excludedErrors;
  }

  /**
   * Is excluded error
   * @param {string} error - The error
   * @returns {boolean} Whether the error is excluded
   */
  isExcludedError(error) {
    return this.#excludedErrors.includes(error);
  }

  /**
   * Exclude an error
   * @param {string} error - The error
   */
  excludeError(error) {
    this.#excludedErrors.push(error);
  }
}

export { Agent };