expressed-core 1.0.0

package/router/node_modules/express-hooked/hooks.js

@@ -0,0 +1,584 @@
+/**
+ * Sistema de Hooks y Filters (Versión independiente para Express)
+ * HOOKED LIB 2.0
+ * Versión 2.0.0
+ * Implementación independiente para el sistema de hooks en Express
+ *
+ * @author Benjamin Sanchez Cardenas
+ * @license Apache 2.0
+ */
+
+class HookSystem {
+  constructor() {
+    // Almacenar acciones registradas
+    this.actions = new Map();
+    // Almacenar filtros registrados
+    this.filters = new Map();
+    // Almacenar namespaces
+    this.namespaces = new Map();
+  }
+
+  /**
+   * Extrae el namespace y el nombre del hook
+   * @private
+   */
+  _parseNamespaceAndHook(hookName) {
+    if (typeof hookName !== 'string' || hookName.trim() === '') {
+      throw new TypeError('hookName debe ser una cadena no vacía');
+    }
+
+    const parts = hookName.split('::');
+    if (parts.length === 1) {
+      return { namespace: null, hookName: parts[0] };
+    } else if (parts.length === 2) {
+      return { namespace: parts[0], hookName: parts[1] };
+    } else {
+      throw new Error('Formato de hook con namespace inválido. Use namespace::hookName');
+    }
+  }
+
+  /**
+   * Obtiene la colección de hooks (acciones o filtros) para un namespace
+   * @private
+   */
+  _getHooksCollection(collectionMap, namespace, hookName) {
+    if (namespace) {
+      if (!this.namespaces.has(namespace)) {
+        this.namespaces.set(namespace, { actions: new Map(), filters: new Map() });
+      }
+
+      const namespaceData = this.namespaces.get(namespace);
+      return namespaceData[collectionMap];
+    }
+    return collectionMap === 'actions' ? this.actions : this.filters;
+  }
+
+  /**
+   * Valida los parámetros comunes para addAction y addFilter
+   * @private
+   */
+  _validateCommonParams(hookName, callback, priority, acceptedArgs) {
+    if (typeof hookName !== 'string' || hookName.trim() === '') {
+      throw new TypeError('hookName debe ser una cadena no vacía');
+    }
+
+    if (typeof callback !== 'function') {
+      throw new TypeError('callback debe ser una función');
+    }
+
+    if (!Number.isInteger(priority) || priority < 0) {
+      throw new TypeError('priority debe ser un número entero no negativo');
+    }
+
+    if (!Number.isInteger(acceptedArgs) || acceptedArgs < 0) {
+      throw new TypeError('acceptedArgs debe ser un número entero no negativo');
+    }
+  }
+
+  /**
+   * Registra una acción
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {Function} callback - Función a ejecutar
+   * @param {number} priority - Prioridad (más bajo se ejecuta primero)
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   * @param {string} [identifier] - Identificador opcional para el callback
+   */
+  addAction(hookName, callback, priority = 10, acceptedArgs = 1, identifier = null) {
+    this._validateCommonParams(hookName, callback, priority, acceptedArgs);
+
+    if (identifier !== null && typeof identifier !== 'string') {
+      throw new TypeError('identifier debe ser una cadena o null');
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+    const collection = this._getHooksCollection('actions', namespace, cleanHookName);
+
+    if (!collection.has(cleanHookName)) {
+      collection.set(cleanHookName, []);
+    }
+
+    const hookList = collection.get(cleanHookName);
+
+    // Crear objeto hook con identificador opcional
+    const hookObject = {
+      callback,
+      priority,
+      acceptedArgs,
+      id: Date.now() + Math.random(),
+      identifier: identifier || null,
+      namespace: namespace
+    };
+
+    // Insertar en la posición correcta manteniendo el orden por prioridad
+    this._insertHookSorted(hookList, hookObject);
+  }
+
+  /**
+   * Registra un filtro
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {Function} callback - Función a ejecutar
+   * @param {number} priority - Prioridad (más bajo se ejecuta primero)
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   * @param {string} [identifier] - Identificador opcional para el callback
+   */
+  addFilter(hookName, callback, priority = 10, acceptedArgs = 1, identifier = null) {
+    this._validateCommonParams(hookName, callback, priority, acceptedArgs);
+
+    if (identifier !== null && typeof identifier !== 'string') {
+      throw new TypeError('identifier debe ser una cadena o null');
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+    const collection = this._getHooksCollection('filters', namespace, cleanHookName);
+
+    if (!collection.has(cleanHookName)) {
+      collection.set(cleanHookName, []);
+    }
+
+    const hookList = collection.get(cleanHookName);
+
+    // Crear objeto hook con identificador opcional
+    const hookObject = {
+      callback,
+      priority,
+      acceptedArgs,
+      id: Date.now() + Math.random(),
+      identifier: identifier || null,
+      namespace: namespace
+    };
+
+    // Insertar en la posición correcta manteniendo el orden por prioridad
+    this._insertHookSorted(hookList, hookObject);
+  }
+
+  /**
+   * Inserta un hook en la posición correcta según la prioridad
+   * @private
+   */
+  _insertHookSorted(hookList, hookObject) {
+    // Encontrar la posición correcta para mantener el orden por prioridad
+    let insertIndex = hookList.length;
+    for (let i = 0; i < hookList.length; i++) {
+      if (hookList[i].priority > hookObject.priority) {
+        insertIndex = i;
+        break;
+      }
+    }
+
+    // Insertar en la posición encontrada
+    hookList.splice(insertIndex, 0, hookObject);
+  }
+
+  /**
+   * Obtiene los hooks para un nombre específico (considerando namespaces)
+   * @private
+   */
+  _getHooks(hookName, type) {
+    if (typeof hookName !== 'string' || hookName.trim() === '') {
+      throw new TypeError('hookName debe ser una cadena no vacía');
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+
+    if (namespace) {
+      const namespaceData = this.namespaces.get(namespace);
+      if (!namespaceData) {
+        return null;
+      }
+      return namespaceData[type].get(cleanHookName);
+    }
+
+    // Buscar en el namespace global
+    return this[type].get(cleanHookName);
+  }
+
+  /**
+   * Ejecuta una acción
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {...any} args - Argumentos a pasar a los callbacks
+   */
+  doAction(hookName, ...args) {
+    const hooks = this._getHooks(hookName, 'actions');
+    if (!hooks || hooks.length === 0) {
+      return;
+    }
+
+    for (const hook of hooks) {
+      // Limitar argumentos según acceptedArgs
+      const callArgs = args.slice(0, hook.acceptedArgs);
+      try {
+        hook.callback(...callArgs);
+      } catch (error) {
+        console.error(`Error ejecutando callback en hook '${hookName}':`, error);
+      }
+    }
+  }
+
+  /**
+   * Ejecuta una acción de forma asíncrona
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {...any} args - Argumentos a pasar a los callbacks
+   * @returns {Promise<void>} - Promesa que se resuelve cuando todas las acciones se completan
+   */
+  async doActionAsync(hookName, ...args) {
+    const hooks = this._getHooks(hookName, 'actions');
+    if (!hooks || hooks.length === 0) {
+      return;
+    }
+
+    const promises = [];
+    for (const hook of hooks) {
+      // Limitar argumentos según acceptedArgs
+      const callArgs = args.slice(0, hook.acceptedArgs);
+      try {
+        const result = hook.callback(...callArgs);
+        // Si el callback retorna una promesa, agregarla al array de promesas
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      } catch (error) {
+        console.error(`Error ejecutando callback en hook '${hookName}':`, error);
+        // Crear una promesa rechazada para manejar el error
+        promises.push(Promise.reject(error));
+      }
+    }
+
+    // Esperar a que todas las promesas se resuelvan
+    await Promise.allSettled(promises);
+  }
+
+  /**
+   * Aplica un filtro
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {any} value - Valor a filtrar
+   * @param {...any} additionalArgs - Argumentos adicionales
+   * @returns {any} - Valor filtrado
+   */
+  applyFilters(hookName, value, ...additionalArgs) {
+    const hooks = this._getHooks(hookName, 'filters');
+    if (!hooks || hooks.length === 0) {
+      return value;
+    }
+
+    let filteredValue = value;
+    for (const hook of hooks) {
+      // El primer argumento es el valor a filtrar, luego los adicionales
+      const callArgs = [filteredValue, ...additionalArgs.slice(0, hook.acceptedArgs - 1)];
+      try {
+        filteredValue = hook.callback(...callArgs);
+      } catch (error) {
+        console.error(`Error aplicando filtro en hook '${hookName}':`, error);
+        // Continuar con el valor anterior en caso de error
+      }
+    }
+
+    return filteredValue;
+  }
+
+  /**
+   * Aplica un filtro de forma asíncrona
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {any} value - Valor a filtrar
+   * @param {...any} additionalArgs - Argumentos adicionales
+   * @returns {Promise<any>} - Promesa que se resuelve con el valor filtrado
+   */
+  async applyFiltersAsync(hookName, value, ...additionalArgs) {
+    const hooks = this._getHooks(hookName, 'filters');
+    if (!hooks || hooks.length === 0) {
+      return value;
+    }
+
+    let filteredValue = value;
+    for (const hook of hooks) {
+      // El primer argumento es el valor a filtrar, luego los adicionales
+      const callArgs = [filteredValue, ...additionalArgs.slice(0, hook.acceptedArgs - 1)];
+      try {
+        // Si el callback retorna una promesa, esperar a que se resuelva
+        filteredValue = await Promise.resolve(hook.callback(...callArgs));
+      } catch (error) {
+        console.error(`Error aplicando filtro en hook '${hookName}':`, error);
+        // Continuar con el valor anterior en caso de error
+      }
+    }
+
+    return filteredValue;
+  }
+
+  /**
+   * Verifica si una acción tiene callbacks registrados
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @returns {boolean} - True si tiene callbacks registrados
+   */
+  hasAction(hookName) {
+    const hooks = this._getHooks(hookName, 'actions');
+    return !!hooks && hooks.length > 0;
+  }
+
+  /**
+   * Verifica si un filtro tiene callbacks registrados
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @returns {boolean} - True si tiene callbacks registrados
+   */
+  hasFilter(hookName) {
+    const hooks = this._getHooks(hookName, 'filters');
+    return !!hooks && hooks.length > 0;
+  }
+
+  /**
+   * Elimina una acción específica
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {Function|string} callbackOrIdentifier - Callback o identificador a eliminar
+   * @param {number} priority - Prioridad del callback (opcional si se usa identificador)
+   * @returns {boolean} - True si se eliminó correctamente
+   */
+  removeAction(hookName, callbackOrIdentifier, priority = 10) {
+    if (typeof hookName !== 'string' || hookName.trim() === '') {
+      throw new TypeError('hookName debe ser una cadena no vacía');
+    }
+
+    if (typeof callbackOrIdentifier !== 'function' && typeof callbackOrIdentifier !== 'string') {
+      throw new TypeError('callbackOrIdentifier debe ser una función o una cadena');
+    }
+
+    if (typeof callbackOrIdentifier === 'string' && arguments.length === 2) {
+      // Si se pasa un identificador y solo hay 2 argumentos, eliminar por identificador en todas las prioridades
+      return this._removeActionByIdentifier(hookName, callbackOrIdentifier);
+    }
+
+    if (!Number.isInteger(priority) || priority < 0) {
+      throw new TypeError('priority debe ser un número entero no negativo');
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+    const collection = this._getHooksCollection('actions', namespace, cleanHookName);
+
+    const hooks = collection.get(cleanHookName);
+    if (!hooks) {
+      return false;
+    }
+
+    const initialLength = hooks.length;
+
+    // Filtrar hooks basándose en función o identificador
+    const filteredHooks = hooks.filter(hook => {
+      if (typeof callbackOrIdentifier === 'function') {
+        return !(hook.callback === callbackOrIdentifier && hook.priority === priority);
+      } else {
+        return !(hook.identifier === callbackOrIdentifier && hook.priority === priority);
+      }
+    });
+
+    if (filteredHooks.length !== initialLength) {
+      if (filteredHooks.length === 0) {
+        collection.delete(cleanHookName);
+      } else {
+        collection.set(cleanHookName, filteredHooks);
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Elimina un filtro específico
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @param {Function|string} callbackOrIdentifier - Callback o identificador a eliminar
+   * @param {number} priority - Prioridad del callback (opcional si se usa identificador)
+   * @returns {boolean} - True si se eliminó correctamente
+   */
+  removeFilter(hookName, callbackOrIdentifier, priority = 10) {
+    if (typeof hookName !== 'string' || hookName.trim() === '') {
+      throw new TypeError('hookName debe ser una cadena no vacía');
+    }
+
+    if (typeof callbackOrIdentifier !== 'function' && typeof callbackOrIdentifier !== 'string') {
+      throw new TypeError('callbackOrIdentifier debe ser una función o una cadena');
+    }
+
+    if (typeof callbackOrIdentifier === 'string' && arguments.length === 2) {
+      // Si se pasa un identificador y solo hay 2 argumentos, eliminar por identificador en todas las prioridades
+      return this._removeFilterByIdentifier(hookName, callbackOrIdentifier);
+    }
+
+    if (!Number.isInteger(priority) || priority < 0) {
+      throw new TypeError('priority debe ser un número entero no negativo');
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+    const collection = this._getHooksCollection('filters', namespace, cleanHookName);
+
+    const hooks = collection.get(cleanHookName);
+    if (!hooks) {
+      return false;
+    }
+
+    const initialLength = hooks.length;
+
+    // Filtrar hooks basándose en función o identificador
+    const filteredHooks = hooks.filter(hook => {
+      if (typeof callbackOrIdentifier === 'function') {
+        return !(hook.callback === callbackOrIdentifier && hook.priority === priority);
+      } else {
+        return !(hook.identifier === callbackOrIdentifier && hook.priority === priority);
+      }
+    });
+
+    if (filteredHooks.length !== initialLength) {
+      if (filteredHooks.length === 0) {
+        collection.delete(cleanHookName);
+      } else {
+        collection.set(cleanHookName, filteredHooks);
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Elimina una acción por identificador en todas las prioridades
+   * @private
+   */
+  _removeActionByIdentifier(hookName, identifier) {
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+    const collection = this._getHooksCollection('actions', namespace, cleanHookName);
+
+    const hooks = collection.get(cleanHookName);
+    if (!hooks) {
+      return false;
+    }
+
+    const initialLength = hooks.length;
+
+    // Filtrar hooks basándose en identificador en todas las prioridades
+    const filteredHooks = hooks.filter(hook => hook.identifier !== identifier);
+
+    if (filteredHooks.length !== initialLength) {
+      if (filteredHooks.length === 0) {
+        collection.delete(cleanHookName);
+      } else {
+        collection.set(cleanHookName, filteredHooks);
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Elimina un filtro por identificador en todas las prioridades
+   * @private
+   */
+  _removeFilterByIdentifier(hookName, identifier) {
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+    const collection = this._getHooksCollection('filters', namespace, cleanHookName);
+
+    const hooks = collection.get(cleanHookName);
+    if (!hooks) {
+      return false;
+    }
+
+    const initialLength = hooks.length;
+
+    // Filtrar hooks basándose en identificador en todas las prioridades
+    const filteredHooks = hooks.filter(hook => hook.identifier !== identifier);
+
+    if (filteredHooks.length !== initialLength) {
+      if (filteredHooks.length === 0) {
+        collection.delete(cleanHookName);
+      } else {
+        collection.set(cleanHookName, filteredHooks);
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Elimina todas las acciones de un hook
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @returns {boolean} - True si se eliminaron correctamente
+   */
+  removeAllActions(hookName) {
+    if (hookName !== undefined && (typeof hookName !== 'string' || hookName.trim() === '')) {
+      throw new TypeError('hookName debe ser una cadena no vacía o undefined');
+    }
+
+    if (!hookName) {
+      this.actions.clear();
+      // Limpiar todos los namespaces también
+      for (const [namespace, data] of this.namespaces.entries()) {
+        data.actions.clear();
+      }
+      return true;
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+
+    if (namespace) {
+      const namespaceData = this.namespaces.get(namespace);
+      if (namespaceData) {
+        return namespaceData.actions.delete(cleanHookName);
+      }
+      return false;
+    }
+
+    return this.actions.delete(cleanHookName);
+  }
+
+  /**
+   * Elimina todos los filtros de un hook
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @returns {boolean} - True si se eliminaron correctamente
+   */
+  removeAllFilters(hookName) {
+    if (hookName !== undefined && (typeof hookName !== 'string' || hookName.trim() === '')) {
+      throw new TypeError('hookName debe ser una cadena no vacía o undefined');
+    }
+
+    if (!hookName) {
+      this.filters.clear();
+      // Limpiar todos los namespaces también
+      for (const [namespace, data] of this.namespaces.entries()) {
+        data.filters.clear();
+      }
+      return true;
+    }
+
+    const { namespace, hookName: cleanHookName } = this._parseNamespaceAndHook(hookName);
+
+    if (namespace) {
+      const namespaceData = this.namespaces.get(namespace);
+      if (namespaceData) {
+        return namespaceData.filters.delete(cleanHookName);
+      }
+      return false;
+    }
+
+    return this.filters.delete(cleanHookName);
+  }
+
+  /**
+   * Obtiene el número de callbacks registrados para una acción
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @returns {number} - Número de callbacks
+   */
+  actionsCount(hookName) {
+    const hooks = this._getHooks(hookName, 'actions');
+    return hooks ? hooks.length : 0;
+  }
+
+  /**
+   * Obtiene el número de callbacks registrados para un filtro
+   * @param {string} hookName - Nombre del hook (puede incluir namespace como namespace::nombre)
+   * @returns {number} - Número de callbacks
+   */
+  filtersCount(hookName) {
+    const hooks = this._getHooks(hookName, 'filters');
+    return hooks ? hooks.length : 0;
+  }
+}
+
+module.exports = HookSystem;

package/router/node_modules/express-hooked/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "express-hooked",
+  "version": "1.0.0",
+  "description": "Hooks system for Express with support for filters and actions",
+  "main": "express-hooked.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "express",
+    "hooks",
+    "middleware",
+    "plugin",
+    "filters",
+    "actions"
+  ],
+  "author": "Benjamin Sanchez Cardenas",
+  "license": "Apache-2.0",
+  "peerDependencies": {
+    "express": "^4.18.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bytedogssyndicate1/express-hooked.git"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/bytedogssyndicate1/express-hooked/issues"
+  },
+  "homepage": "https://gitlab.com/bytedogssyndicate1/express-hooked#readme"
+}