@apiquest/fracture 1.0.2 → 1.0.4

package/src/Logger.ts

@@ -1,85 +1,85 @@
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { ILogger, LogLevel } from '@apiquest/types';
-
-/**
- * Logger for fracture runtime and host integrations.
- */
-export class Logger implements ILogger {
-  private level: LogLevel;
-  private component: string;
-  private emitter?: EventEmitter;
-
-  constructor(component: string, level: LogLevel = LogLevel.INFO, emitter?: EventEmitter) {
-    this.component = component;
-    this.level = level;
-    this.emitter = emitter;
-  }
-
-  createLogger(component: string): Logger {
-    return new Logger(component, this.level, this.emitter);
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level;
-  }
-
-  error(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.ERROR, message, ...args);
-  }
-
-  warn(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.WARN, message, ...args);
-  }
-
-  info(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.INFO, message, ...args);
-  }
-
-  debug(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.DEBUG, message, ...args);
-  }
-
-  trace(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.TRACE, message, ...args);
-  }
-
-  private log(level: LogLevel, message: string, ...args: unknown[]): void {
-    if (level > this.level) return;
-
-    const levelNames = ['error', 'warn', 'info', 'debug', 'trace'];
-    const levelName = levelNames[level];
-    const prefix = `[${this.component}]`;
-    const fullMessage = `${prefix} ${message}`;
-
-    const formattedArgs = args.length > 0
-      ? ' ' + args.map(a => {
-        if (a instanceof Error) {
-          return a.message;
-        }
-        if (typeof a === 'object' && a !== null) {
-          try {
-            return JSON.stringify(a);
-          } catch {
-            return String(a);
-          }
-        }
-        return String(a);
-      }).join(' ')
-      : '';
-
-    const finalMessage = fullMessage + formattedArgs;
-
-    if (this.emitter !== null && this.emitter !== undefined) {
-      this.emitter.emit('console', {
-        id: randomUUID(),
-        level,
-        levelName,
-        component: this.component,
-        message: finalMessage,
-        args,
-        timestamp: new Date().toISOString()
-      });
-    }
-  }
-}
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { ILogger, LogLevel } from '@apiquest/types';
+
+/**
+ * Logger for fracture runtime and host integrations.
+ */
+export class Logger implements ILogger {
+  private level: LogLevel;
+  private component: string;
+  private emitter?: EventEmitter;
+
+  constructor(component: string, level: LogLevel = LogLevel.INFO, emitter?: EventEmitter) {
+    this.component = component;
+    this.level = level;
+    this.emitter = emitter;
+  }
+
+  createLogger(component: string): Logger {
+    return new Logger(component, this.level, this.emitter);
+  }
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.ERROR, message, ...args);
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.WARN, message, ...args);
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.INFO, message, ...args);
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.DEBUG, message, ...args);
+  }
+
+  trace(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.TRACE, message, ...args);
+  }
+
+  private log(level: LogLevel, message: string, ...args: unknown[]): void {
+    if (level > this.level) return;
+
+    const levelNames = ['error', 'warn', 'info', 'debug', 'trace'];
+    const levelName = levelNames[level];
+    const prefix = `[${this.component}]`;
+    const fullMessage = `${prefix} ${message}`;
+
+    const formattedArgs = args.length > 0
+      ? ' ' + args.map(a => {
+        if (a instanceof Error) {
+          return a.message;
+        }
+        if (typeof a === 'object' && a !== null) {
+          try {
+            return JSON.stringify(a);
+          } catch {
+            return String(a);
+          }
+        }
+        return String(a);
+      }).join(' ')
+      : '';
+
+    const finalMessage = fullMessage + formattedArgs;
+
+    if (this.emitter !== null && this.emitter !== undefined) {
+      this.emitter.emit('console', {
+        id: randomUUID(),
+        level,
+        levelName,
+        component: this.component,
+        message: finalMessage,
+        args,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+}

package/src/PluginLoader.ts

@@ -1,126 +1,126 @@
-import type { IProtocolPlugin, IAuthPlugin, IValueProviderPlugin } from '@apiquest/types';
-import { Logger } from './Logger.js';
-import { PluginManager } from './PluginManager.js';
-import type { ResolvedPlugin } from './PluginResolver.js';
-import type { PluginRequirements } from './CollectionAnalyzer.js';
-import { isNullOrEmpty } from './utils.js';
-
-export class PluginLoader {
-  private logger: Logger;
-  private pluginManager: PluginManager;
-  private loadedPlugins: Set<string> = new Set();
-
-  constructor(pluginManager: PluginManager, baseLogger?: Logger) {
-    this.pluginManager = pluginManager;
-    this.logger = baseLogger?.createLogger('PluginLoader') ?? new Logger('PluginLoader');
-  }
-
-  /**
-   * Load only plugins needed by the collection
-   */
-  async loadRequiredPlugins(
-    resolved: ResolvedPlugin[],
-    requirements: PluginRequirements
-  ): Promise<void> {
-    const needed = this.filterNeededPlugins(resolved, requirements);
-    
-    this.logger.info(`Loading ${needed.length} required plugins (${resolved.length} available)`);
-    
-    const loadPromises = needed.map(plugin =>
-      this.loadPlugin(plugin).catch(err => {
-        this.logger.error(`Failed to load ${plugin.name}:`, err);
-        throw err;
-      })
-    );
-    
-    await Promise.all(loadPromises);
-    this.logger.debug('Required plugins loaded');
-  }
-
-  /**
-   * Filter resolved plugins to only those needed by collection
-   */
-  private filterNeededPlugins(
-    resolved: ResolvedPlugin[],
-    requirements: PluginRequirements
-  ): ResolvedPlugin[] {
-    const needed: ResolvedPlugin[] = [];
-
-    for (const plugin of resolved) {
-      let isNeeded = false;
-
-      if (plugin.type === 'protocol') {
-        // Check if collection uses this protocol
-        if (plugin.protocols?.some(p => requirements.protocols.has(p)) === true) {
-          isNeeded = true;
-        }
-      } else if (plugin.type === 'auth') {
-        // Check if collection uses any of these auth types
-        if (plugin.authTypes?.some(a => requirements.authTypes.has(a)) === true) {
-          isNeeded = true;
-        }
-      } else if (plugin.type === 'value') {
-        // Check if collection uses this value provider
-        const provider = plugin.provider;
-        if (provider !== null && provider !== undefined && provider !== '' && requirements.valueProviders.has(provider)) {
-          isNeeded = true;
-        }
-      }
-
-      if (isNeeded) {
-        this.logger.debug(`Plugin needed: ${plugin.name} v${plugin.version} (${plugin.type})`);
-        needed.push(plugin);
-      }
-    }
-
-    return needed;
-  }
-
-  /**
-   * Dynamically import and register a single plugin
-   */
-  private async loadPlugin(plugin: ResolvedPlugin): Promise<void> {
-    const { pathToFileURL } = await import('url');
-
-    // Skip if already loaded
-    if (this.loadedPlugins.has(plugin.name)) {
-      this.logger.debug(`Already loaded: ${plugin.name}`);
-      return;
-    }
-
-    this.logger.debug(`Loading ${plugin.name} v${plugin.version} from ${plugin.path}`);
-
-    // Mark as loaded
-    this.loadedPlugins.add(plugin.name);
-
-    // Convert to file:// URL for Windows compatibility
-    const moduleUrl = pathToFileURL(plugin.entryPoint).href;
-    const pluginModule = await import(moduleUrl) as Record<string, unknown>;
-
-    // Handle different export patterns
-    const defaultExport = pluginModule.default;
-    const namedExport = pluginModule[Object.keys(pluginModule)[0]];
-    const exported = defaultExport ?? namedExport;
-
-    if (exported === null || exported === undefined) {
-      throw new Error(`Plugin ${plugin.name} has no exports`);
-    }
-
-    // Register based on plugin type
-    if (plugin.type === 'protocol') {
-      this.pluginManager.registerPlugin(exported as IProtocolPlugin);
-      this.logger.debug(`Registered protocol plugin: ${plugin.protocols?.join(', ') ?? ''}`);
-    } else if (plugin.type === 'auth') {
-      // Auth plugins might export array or single
-      const authArray = Array.isArray(exported) ? (exported as IAuthPlugin[]) : [exported as IAuthPlugin];
-
-      for (const authPlugin of authArray) {
-        this.pluginManager.registerAuthPlugin(authPlugin);
-        this.logger.debug(`Registered auth plugin: ${authPlugin.authTypes.join(', ')}`);
-      }
-    } else if (plugin.type === 'value') {
-      this.pluginManager.registerVariableProvider(exported as IValueProviderPlugin);
-      this.logger.debug(`Registered value provider: ${plugin.provider ?? ''}`);
-    }
-  }
-}
+import type { IProtocolPlugin, IAuthPlugin, IValueProviderPlugin } from '@apiquest/types';
+import { Logger } from './Logger.js';
+import { PluginManager } from './PluginManager.js';
+import type { ResolvedPlugin } from './PluginResolver.js';
+import type { PluginRequirements } from './CollectionAnalyzer.js';
+import { isNullOrEmpty } from './utils.js';
+
+export class PluginLoader {
+  private logger: Logger;
+  private pluginManager: PluginManager;
+  private loadedPlugins: Set<string> = new Set();
+
+  constructor(pluginManager: PluginManager, baseLogger?: Logger) {
+    this.pluginManager = pluginManager;
+    this.logger = baseLogger?.createLogger('PluginLoader') ?? new Logger('PluginLoader');
+  }
+
+  /**
+   * Load only plugins needed by the collection
+   */
+  async loadRequiredPlugins(
+    resolved: ResolvedPlugin[],
+    requirements: PluginRequirements
+  ): Promise<void> {
+    const needed = this.filterNeededPlugins(resolved, requirements);
+    
+    this.logger.info(`Loading ${needed.length} required plugins (${resolved.length} available)`);
+    
+    const loadPromises = needed.map(plugin =>
+      this.loadPlugin(plugin).catch(err => {
+        this.logger.error(`Failed to load ${plugin.name}:`, err);
+        throw err;
+      })
+    );
+    
+    await Promise.all(loadPromises);
+    this.logger.debug('Required plugins loaded');
+  }
+
+  /**
+   * Filter resolved plugins to only those needed by collection
+   */
+  private filterNeededPlugins(
+    resolved: ResolvedPlugin[],
+    requirements: PluginRequirements
+  ): ResolvedPlugin[] {
+    const needed: ResolvedPlugin[] = [];
+
+    for (const plugin of resolved) {
+      let isNeeded = false;
+
+      if (plugin.type === 'protocol') {
+        // Check if collection uses this protocol
+        if (plugin.protocols?.some(p => requirements.protocols.has(p)) === true) {
+          isNeeded = true;
+        }
+      } else if (plugin.type === 'auth') {
+        // Check if collection uses any of these auth types
+        if (plugin.authTypes?.some(a => requirements.authTypes.has(a)) === true) {
+          isNeeded = true;
+        }
+      } else if (plugin.type === 'value') {
+        // Check if collection uses this value provider
+        const provider = plugin.provider;
+        if (provider !== null && provider !== undefined && provider !== '' && requirements.valueProviders.has(provider)) {
+          isNeeded = true;
+        }
+      }
+
+      if (isNeeded) {
+        this.logger.debug(`Plugin needed: ${plugin.name} v${plugin.version} (${plugin.type})`);
+        needed.push(plugin);
+      }
+    }
+
+    return needed;
+  }
+
+  /**
+   * Dynamically import and register a single plugin
+   */
+  private async loadPlugin(plugin: ResolvedPlugin): Promise<void> {
+    const { pathToFileURL } = await import('url');
+
+    // Skip if already loaded
+    if (this.loadedPlugins.has(plugin.name)) {
+      this.logger.debug(`Already loaded: ${plugin.name}`);
+      return;
+    }
+
+    this.logger.debug(`Loading ${plugin.name} v${plugin.version} from ${plugin.path}`);
+
+    // Mark as loaded
+    this.loadedPlugins.add(plugin.name);
+
+    // Convert to file:// URL for Windows compatibility
+    const moduleUrl = pathToFileURL(plugin.entryPoint).href;
+    const pluginModule = await import(moduleUrl) as Record<string, unknown>;
+
+    // Handle different export patterns
+    const defaultExport = pluginModule.default;
+    const namedExport = pluginModule[Object.keys(pluginModule)[0]];
+    const exported = defaultExport ?? namedExport;
+
+    if (exported === null || exported === undefined) {
+      throw new Error(`Plugin ${plugin.name} has no exports`);
+    }
+
+    // Register based on plugin type
+    if (plugin.type === 'protocol') {
+      this.pluginManager.registerPlugin(exported as IProtocolPlugin);
+      this.logger.debug(`Registered protocol plugin: ${plugin.protocols?.join(', ') ?? ''}`);
+    } else if (plugin.type === 'auth') {
+      // Auth plugins might export array or single
+      const authArray = Array.isArray(exported) ? (exported as IAuthPlugin[]) : [exported as IAuthPlugin];
+
+      for (const authPlugin of authArray) {
+        this.pluginManager.registerAuthPlugin(authPlugin);
+        this.logger.debug(`Registered auth plugin: ${authPlugin.authTypes.join(', ')}`);
+      }
+    } else if (plugin.type === 'value') {
+      this.pluginManager.registerVariableProvider(exported as IValueProviderPlugin);
+      this.logger.debug(`Registered value provider: ${plugin.provider ?? ''}`);
+    }
+  }
+}