jtcsv 3.0.0 → 3.1.0

package/src/core/plugin-system.ts

@@ -6,15 +6,22 @@
  * @date 2026-01-22
  */
 
-interface PluginStats {
+interface PluginStatsCounters {
   pluginLoads: number;
   hookExecutions: number;
   middlewareExecutions: number;
 }
 
+interface PluginStats extends PluginStatsCounters {
+  plugins: number;
+  hooks: number;
+  middlewares: number;
+  uniqueHooks: number;
+}
+
 interface Plugin {
   name: string;
-  version?: string;
+  version: string;
   description?: string;
   hooks?: Record<string, Function>;
   middlewares?: Function[];
@@ -22,6 +29,23 @@ interface Plugin {
   destroy?: () => void;
 }
 
+interface PluginRecord extends Plugin {
+  id: string;
+  enabled: boolean;
+}
+
+interface HookHandlerEntry {
+  handler: Function;
+  pluginName?: string;
+  executionCount: number;
+}
+
+interface MiddlewareEntry {
+  handler: Function;
+  pluginName?: string;
+  executionCount: number;
+}
+
 type HookName = 
   | 'before:csvToJson'
   | 'after:csvToJson'
@@ -36,14 +60,16 @@ type HookName =
   | 'transformation'
   | string;
 
-export class PluginManager {
-  private plugins: Map<string, Plugin>;
-  private hooks: Map<HookName, Function[]>;
-  private middlewares: Function[];
+const SLOW_HOOK_THRESHOLD_MS = 100;
+
+export class PluginManager {
+  private plugins: Map<string, PluginRecord>;
+  private hooks: Map<HookName, HookHandlerEntry[]>;
+  private middlewares: MiddlewareEntry[];
   private context: Record<string, any>;
-  private stats: PluginStats;
+  private stats: PluginStatsCounters;
 
-  constructor() {
+  constructor() {
     this.plugins = new Map();
     this.hooks = new Map();
     this.middlewares = [];
@@ -56,14 +82,14 @@ export class PluginManager {
 
     // Регистрируем стандартные hooks
     this._registerDefaultHooks();
-  }
-
-  /**
-   * Backwards-compatible alias for registerPlugin.
-   */
-  use(name: string, plugin: Plugin): void {
-    this.registerPlugin(name, plugin);
-  }
+  }
+
+  /**
+   * Backwards-compatible alias for registerPlugin.
+   */
+  use(name: string, plugin: Plugin): void {
+    this.registerPlugin(name, plugin);
+  }
 
   /**
    * Регистрирует стандартные hooks
@@ -94,176 +120,333 @@ export class PluginManager {
    * @param plugin - Объект плагина
    */
   registerPlugin(name: string, plugin: Plugin): void {
+    if (!plugin || typeof plugin !== 'object' || !plugin.name || !plugin.version) {
+      throw new Error('Plugin должен иметь name и version');
+    }
+
     if (this.plugins.has(name)) {
-      throw new Error(`Plugin "${name}" already registered`);
+      throw new Error(`Plugin "${name}" уже зарегистрирован`);
+    }
+
+    if (plugin.hooks && (typeof plugin.hooks !== 'object' || Array.isArray(plugin.hooks))) {
+      throw new Error('hooks must be an object');
     }
 
-    // Добавляем плагин
-    this.plugins.set(name, plugin);
+    if (plugin.hooks) {
+      for (const [hookName, handler] of Object.entries(plugin.hooks)) {
+        if (typeof handler !== 'function') {
+          throw new Error(`Hook handler for "${hookName}" must be a function`);
+        }
+      }
+    }
+
+    if (plugin.middlewares && !Array.isArray(plugin.middlewares)) {
+      throw new Error('middlewares must be an array');
+    }
+
+    if (plugin.middlewares) {
+      plugin.middlewares.forEach((middleware, index) => {
+        if (typeof middleware !== 'function') {
+          throw new Error(`Middleware ${index} must be a function`);
+        }
+      });
+    }
+
+    const record: PluginRecord = {
+      id: name,
+      enabled: true,
+      ...plugin
+    };
+
+    // ?????????????????? ????????????
+    this.plugins.set(name, record);
     this.stats.pluginLoads++;
 
-    // Регистрируем hooks плагина
+    // ?????????????????????? hooks ??????????????
     if (plugin.hooks) {
       Object.entries(plugin.hooks).forEach(([hookName, handler]) => {
-        this.registerHook(hookName as HookName, handler);
+        this.registerHook(hookName as HookName, handler, name);
       });
     }
 
-    // Регистрируем middleware плагина
+    // ?????????????????????? middleware ??????????????
     if (plugin.middlewares) {
       plugin.middlewares.forEach(middleware => {
-        this.registerMiddleware(middleware);
+        this.registerMiddleware(middleware, name);
       });
     }
 
-    // Вызываем init если есть
+    // ???????????????? init ???????? ????????
     if (plugin.init) {
       plugin.init(this);
     }
-
-    console.log(`✅ Plugin "${name}" registered successfully`);
   }
 
-  /**
-   * Регистрирует hook
-   * @param hookName - Имя hook
-   * @param handler - Функция обработчик
-   */
-  registerHook(hookName: HookName, handler: Function): void {
+  registerHook(hookName: HookName, handler: Function, pluginName?: string): void {
+    if (typeof handler != 'function') {
+      throw new Error('Hook handler must be a function');
+    }
     if (!this.hooks.has(hookName)) {
       this.hooks.set(hookName, []);
     }
 
     const handlers = this.hooks.get(hookName)!;
-    handlers.push(handler);
+    handlers.push({
+      handler,
+      pluginName,
+      executionCount: 0
+    });
   }
 
-  /**
-   * Регистрирует middleware
-   * @param middleware - Функция middleware
-   */
-  registerMiddleware(middleware: Function): void {
-    this.middlewares.push(middleware);
+  registerMiddleware(middleware: Function, pluginName?: string): void {
+    if (typeof middleware !== 'function') {
+      throw new Error('Middleware must be a function');
+    }
+    this.middlewares.push({
+      handler: middleware,
+      pluginName,
+      executionCount: 0
+    });
   }
 
-  /**
-   * Выполняет hook
-   * @param hookName - Имя hook
-   * @param data - Данные для обработки
-   * @param context - Контекст выполнения
-   */
-  async executeHook(hookName: HookName, data: any, context: any = {}): Promise<any> {
+  private _isPluginEnabled(pluginName?: string): boolean {
+    if (!pluginName) {
+      return true;
+    }
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      return true;
+    }
+    return plugin.enabled !== false;
+  }
+
+  private _runErrorHooks(error: any, context: any): void {
+    const errorHandlers = this.hooks.get('error');
+    if (!errorHandlers || errorHandlers.length == 0) {
+      return;
+    }
+    for (const handlerEntry of errorHandlers) {
+      try {
+        handlerEntry.handler(error, context);
+      } catch {
+        // ignore errors in error handlers
+      }
+    }
+  }
+
+  async executeHook(hookName: HookName, data: any, context: any = {}): Promise<any> {
     const handlers = this.hooks.get(hookName);
-    
+
     if (!handlers || handlers.length === 0) {
       return data;
     }
 
-    this.stats.hookExecutions++;
     let result = data;
+    let executed = false;
 
-    // Выполняем все handlers последовательно
-    for (const handler of handlers) {
+    for (const handlerEntry of handlers) {
+      if (!this._isPluginEnabled(handlerEntry.pluginName)) {
+        continue;
+      }
+
+      executed = true;
+      const startTime = Date.now();
       try {
-        result = await handler(result, { ...this.context, ...context, hookName });
+        result = await handlerEntry.handler(result, { ...this.context, ...context, hookName, plugin: handlerEntry.pluginName });
+        handlerEntry.executionCount++;
       } catch (error) {
-        console.error(`Error in hook "${hookName}":`, error);
-        
-        // Выполняем error hook если есть
-        const errorHandlers = this.hooks.get('error');
-        if (errorHandlers && errorHandlers.length > 0) {
-          for (const errorHandler of errorHandlers) {
-            try {
-              errorHandler(error, { ...this.context, ...context, hookName, data: result });
-            } catch {
-              // Игнорируем ошибки в error handlers
-            }
-          }
+        this._runErrorHooks(error, { ...this.context, ...context, hookName, data: result });
+      } finally {
+        const duration = Date.now() - startTime;
+        if (duration > SLOW_HOOK_THRESHOLD_MS) {
+          console.warn(`Slow hook "${hookName}" detected (${duration}ms)`);
         }
       }
     }
 
+    if (executed) {
+      this.stats.hookExecutions++;
+    }
+
     return result;
-  }
-
-  /**
-   * Backwards-compatible alias for executeHook.
-   */
-  async executeHooks(hookName: HookName, data: any, context: any = {}): Promise<any> {
-    return this.executeHook(hookName, data, context);
-  }
-
-  /**
-   * Executes an operation with before/after hooks and middleware.
-   */
-  async executeWithPlugins(
-    operation: string,
-    input: any,
-    options: any,
-    handler: (input: any, options: any) => any | Promise<any>
-  ): Promise<any> {
-    const context = { operation, options, metadata: {} as Record<string, any> };
-    const beforeHook = `before:${operation}` as HookName;
-    const afterHook = `after:${operation}` as HookName;
-
-    const beforeInput = await this.executeHook(beforeHook, input, context);
-    const middlewareInput = { input: beforeInput, options, operation, metadata: context.metadata };
-    const middlewareResult = await this.executeMiddleware(middlewareInput, context);
-    const result = await handler(middlewareResult.input ?? beforeInput, options);
-    return this.executeHook(afterHook, result, context);
-  }
-
-  /**
-   * Returns registered plugin names.
-   */
-  listPlugins(): string[] {
-    return Array.from(this.plugins.keys());
-  }
+  }
 
   /**
-   * Выполняет цепочку middleware
-   * @param input - Входные данные
-   * @param context - Контекст выполнения
+   * Backwards-compatible alias for executeHook.
    */
-  async executeMiddleware(input: any, context: any = {}): Promise<any> {
-    if (this.middlewares.length === 0) {
-      return input;
+  async executeHooks(hookName: HookName, data: any, context: any = {}): Promise<any> {
+    return this.executeHook(hookName, data, context);
+  }
+
+  /**
+   * Executes an operation with before/after hooks and middleware.
+   */
+  async executeWithPlugins(
+    operation: string,
+    input: any,
+    options: any,
+    handler: (input: any, options: any) => any | Promise<any>
+  ): Promise<any> {
+    const metadata = options && options.metadata ? options.metadata : {};
+    const context = { operation, options, metadata };
+    const beforeHook = `before:${operation}` as HookName;
+    const afterHook = `after:${operation}` as HookName;
+
+    const beforeInput = await this.executeHook(beforeHook, input, context);
+    const middlewareContext: { input: any; options: any; operation: string; metadata: any; result?: any } = {
+      input: beforeInput,
+      options,
+      operation,
+      metadata
+    };
+    const resultHolder = { set: false, value: undefined as any };
+
+    try {
+      await this.executeMiddlewares(middlewareContext, context, async (ctx: any) => {
+        const handlerInput = ctx && Object.prototype.hasOwnProperty.call(ctx, 'input')
+          ? ctx.input
+          : beforeInput;
+        const result = await handler(handlerInput, options);
+        ctx.result = result;
+        resultHolder.set = true;
+        resultHolder.value = result;
+        return result;
+      });
+    } catch (error) {
+      this._runErrorHooks(error, { ...this.context, ...context, data: beforeInput });
+      throw error;
+    }
+
+    const finalResult = resultHolder.set
+      ? resultHolder.value
+      : (Object.prototype.hasOwnProperty.call(middlewareContext, 'result') ? middlewareContext.result : undefined);
+
+    return this.executeHook(afterHook, finalResult, context);
+  }
+
+  /**
+   * Returns registered plugin names.
+   */
+  listPlugins(): Array<{ id: string; pluginName: string; version: string; description?: string; enabled: boolean }> {
+    return Array.from(this.plugins.values()).map((plugin) => ({
+      id: plugin.id,
+      pluginName: plugin.name,
+      version: plugin.version,
+      description: plugin.description,
+      enabled: plugin.enabled
+    }));
+  }
+
+  listHooks(): Record<string, { count: number; handlers: Array<{ handler: Function; pluginName?: string; executionCount: number }> }> {
+    const result: Record<string, { count: number; handlers: Array<{ handler: Function; pluginName?: string; executionCount: number }> }> = {};
+    for (const [hookName, handlers] of this.hooks.entries()) {
+      result[hookName] = {
+        count: handlers.length,
+        handlers: handlers.map((handlerEntry) => ({
+          handler: handlerEntry.handler,
+          pluginName: handlerEntry.pluginName,
+          executionCount: handlerEntry.executionCount
+        }))
+      };
+    }
+    return result;
+  }
+
+
+  setPluginEnabled(name: string, enabled: boolean): void {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin "${name}" не найден`);
     }
+    plugin.enabled = Boolean(enabled);
+  }
 
-    this.stats.middlewareExecutions++;
-    let result = input;
+  removePlugin(name: string): boolean {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin "${name}" не найден`);
+    }
 
-    // Выполняем middleware последовательно
-    for (const middleware of this.middlewares) {
+    if (plugin.destroy) {
       try {
-        result = await middleware(result, { ...this.context, ...context });
+        plugin.destroy();
       } catch (error) {
-        console.error('Error in middleware:', error);
-        
-        // Выполняем error hook если есть
-        const errorHandlers = this.hooks.get('error');
-        if (errorHandlers && errorHandlers.length > 0) {
-          for (const errorHandler of errorHandlers) {
-            try {
-              errorHandler(error, { ...this.context, ...context, data: result });
-            } catch {
-              // Игнорируем ошибки в error handlers
-            }
-          }
+        console.error(`Error destroying plugin "${name}":`, error);
+      }
+    }
+
+    this.plugins.delete(name);
+
+    for (const [hookName, handlers] of this.hooks.entries()) {
+      if (!handlers.length) {
+        continue;
+      }
+      const remaining = handlers.filter((handlerEntry) => handlerEntry.pluginName !== name);
+      this.hooks.set(hookName, remaining);
+    }
+
+    this.middlewares = this.middlewares.filter((middleware) => middleware.pluginName !== name);
+
+    return true;
+  }
+
+  resetStats(): void {
+    this.stats.pluginLoads = 0;
+    this.stats.hookExecutions = 0;
+    this.stats.middlewareExecutions = 0;
+  }
+
+  async executeMiddlewares(ctx: any, context: any = {}, finalHandler?: (ctx: any) => any | Promise<any>): Promise<any> {
+    const entries = this.middlewares.filter((entry) => this._isPluginEnabled(entry.pluginName));
+    if (entries.length === 0) {
+      if (finalHandler) {
+        await finalHandler(ctx);
+      }
+      return ctx;
+    }
+
+    let index = -1;
+    const dispatch = async (i: number): Promise<any> => {
+      if (i <= index) {
+        throw new Error('next() вызван несколько раз');
+      }
+      index = i;
+      const entry = entries[i];
+      if (!entry) {
+        if (finalHandler) {
+          return finalHandler(ctx);
         }
-        
+        return;
+      }
+
+      const startTime = Date.now();
+      try {
+        const result = entry.handler(ctx, () => dispatch(i + 1));
+        await result;
+        entry.executionCount++;
+        this.stats.middlewareExecutions++;
+      } catch (error) {
+        this._runErrorHooks(error, { ...this.context, ...context, data: ctx });
         throw error;
+      } finally {
+        const duration = Date.now() - startTime;
+        if (duration > SLOW_HOOK_THRESHOLD_MS) {
+          console.warn(`Slow middleware "${entry.pluginName || 'anonymous'}" detected (${duration}ms)`);
+        }
       }
-    }
+    };
 
-    return result;
+    await dispatch(0);
+    return ctx;
   }
 
   /**
-   * Устанавливает контекст
-   * @param key - Ключ контекста
-   * @param value - Значение
+   * Backwards-compatible alias for executeMiddlewares.
    */
+  async executeMiddleware(input: any, context: any = {}): Promise<any> {
+    return this.executeMiddlewares(input, context);
+  }
+
   setContext(key: string, value: any): void {
     this.context[key] = value;
   }
@@ -283,7 +466,18 @@ export class PluginManager {
    * Возвращает статистику
    */
   getStats(): PluginStats {
-    return { ...this.stats };
+    let hookCount = 0;
+    for (const handlers of this.hooks.values()) {
+      hookCount += handlers.length;
+    }
+
+    return {
+      ...this.stats,
+      plugins: this.plugins.size,
+      hooks: hookCount,
+      middlewares: this.middlewares.length,
+      uniqueHooks: this.hooks.size
+    };
   }
 
   /**
@@ -305,28 +499,12 @@ export class PluginManager {
    * @param name - Имя плагина
    */
   unregisterPlugin(name: string): boolean {
-    const plugin = this.plugins.get(name);
-    
-    if (!plugin) {
+    try {
+      this.removePlugin(name);
+      return true;
+    } catch {
       return false;
     }
-
-    // Вызываем destroy если есть
-    if (plugin.destroy) {
-      try {
-        plugin.destroy();
-      } catch (error) {
-        console.error(`Error destroying plugin "${name}":`, error);
-      }
-    }
-
-    // Удаляем плагин
-    this.plugins.delete(name);
-    
-    // TODO: Удалить связанные hooks и middleware
-    
-    console.log(`🗑️ Plugin "${name}" unregistered`);
-    return true;
   }
 
   /**
@@ -366,7 +544,7 @@ export class PluginManager {
    * Асинхронная версия executeMiddleware
    */
   async executeMiddlewareAsync(input: any, context: any = {}): Promise<any> {
-    return this.executeMiddleware(input, context);
+    return this.executeMiddlewares(input, context);
   }
 }
 
@@ -390,11 +568,21 @@ export async function getGlobalPluginManagerAsync(): Promise<PluginManager> {
   return getGlobalPluginManager();
 }
 
+export default PluginManager;
+
 // Экспорт для CommonJS
 if (typeof module !== 'undefined' && module.exports) {
-  module.exports = {
-    PluginManager,
-    getGlobalPluginManager,
-    getGlobalPluginManagerAsync
-  };
-}
+  const current = module.exports;
+  if (current && current.__esModule) {
+    current.PluginManager = PluginManager;
+    current.getGlobalPluginManager = getGlobalPluginManager;
+    current.getGlobalPluginManagerAsync = getGlobalPluginManagerAsync;
+    current.default = PluginManager;
+  } else {
+    module.exports = PluginManager;
+    module.exports.PluginManager = PluginManager;
+    module.exports.getGlobalPluginManager = getGlobalPluginManager;
+    module.exports.getGlobalPluginManagerAsync = getGlobalPluginManagerAsync;
+    module.exports.default = PluginManager;
+  }
+}

package/src/core/transform-hooks.ts

@@ -445,11 +445,11 @@ export const predefinedHooks = {
    * @param onError - Обработчик ошибки
    * @returns Хук валидации
    */
-  validate<T>(validator: (item: T, index: number) => boolean, onError: (errors: any[]) => void = console.error): HookFunction<T[], T[]> {
-    return (data: T[]) => {
-      if (Array.isArray(data)) {
-        const validData: T[] = [];
-        const errors: any[] = [];
+  validate<T>(validator: (item: T, index: number) => boolean, onError: (errors: any[] | string, details?: any[]) => void = console.error): HookFunction<T[], T[]> {
+    return (data: T[]) => {
+      if (Array.isArray(data)) {
+        const validData: T[] = [];
+        const errors: any[] = [];
 
         data.forEach((item, index) => {
           try {
@@ -464,9 +464,13 @@ export const predefinedHooks = {
           }
         });
 
-        if (errors.length > 0) {
-          onError(errors);
-        }
+        if (errors.length > 0) {
+          if (onError.length >= 2) {
+            onError('Validation errors', errors);
+          } else {
+            onError(errors);
+          }
+        }
 
         return validData;
       }
@@ -480,7 +484,7 @@ export const predefinedHooks = {
    * @param onError - Обработчик ошибки
    * @returns Асинхронный хук валидации
    */
-  validateAsync<T>(validator: (item: T, index: number) => Promise<boolean>, onError: (errors: any[]) => void = console.error): AsyncHookFunction<T[], T[]> {
+  validateAsync<T>(validator: (item: T, index: number) => Promise<boolean>, onError: (errors: any[] | string, details?: any[]) => void = console.error): AsyncHookFunction<T[], T[]> {
     return async (data: T[]) => {
       if (Array.isArray(data)) {
         const validData: T[] = [];
@@ -499,9 +503,13 @@ export const predefinedHooks = {
           }
         }
 
-        if (errors.length > 0) {
-          onError(errors);
-        }
+        if (errors.length > 0) {
+          if (onError.length >= 2) {
+            onError('Validation errors', errors);
+          } else {
+            onError(errors);
+          }
+        }
 
         return validData;
       }