@apiquest/fracture 1.0.4 → 1.0.5

package/src/PluginManager.ts

@@ -1,208 +0,0 @@
-import type { IProtocolPlugin, IAuthPlugin, IValueProviderPlugin, Request, ExecutionContext, ProtocolResponse, RuntimeOptions, Auth } from '@apiquest/types';
-import { Logger } from './Logger.js';
-
-export class PluginManager {
-  private plugins: Map<string, IProtocolPlugin> = new Map();
-  private authPlugins: Map<string, IAuthPlugin> = new Map();
-  private variableProviders: Map<string, IValueProviderPlugin> = new Map();
-  private logger: Logger;
-
-  constructor(baseLogger?: Logger) {
-    this.logger = baseLogger?.createLogger('PluginManager') ?? new Logger('PluginManager');
-  }
-
-  /**
-   * Register a protocol plugin
-   */
-  registerPlugin(plugin: IProtocolPlugin): void {
-    // Register plugin for each protocol it provides
-    for (const protocol of plugin.protocols) {
-      this.plugins.set(protocol, plugin);
-      this.logger.debug(`Registered protocol plugin: ${plugin.name} for protocol '${protocol}'`);
-    }
-  }
-
-  /**
-   * Register an auth plugin
-   */
-  registerAuthPlugin(plugin: IAuthPlugin): void {
-    // Register plugin for each auth type it provides
-    for (const authType of plugin.authTypes) {
-      this.authPlugins.set(authType, plugin);
-      this.logger.debug(`Registered auth plugin: ${plugin.name} for type '${authType}'`);
-    }
-  }
-
-  /**
-   * Register a variable provider plugin
-   */
-  registerVariableProvider(plugin: IValueProviderPlugin): void {
-    this.variableProviders.set(plugin.provider, plugin);
-    this.logger.debug(`Registered vault provider: ${plugin.name} (${plugin.provider})`);
-  }
-
-  /**
-   * Get plugin for a protocol
-   */
-  getPlugin(protocol: string): IProtocolPlugin | undefined {
-    return this.plugins.get(protocol);
-  }
-
-  /**
-   * Get auth plugin for a type
-   */
-  getAuthPlugin(type: string): IAuthPlugin | undefined {
-    return this.authPlugins.get(type);
-  }
-
-  /**
-   * Apply auth to request if auth is configured
-   */
-  private async applyAuth(request: Request, auth: Auth, options: RuntimeOptions): Promise<Request> {
-    if (auth.type === 'none' || auth.type === 'inherit') {
-      return request;
-    }
-
-    const authPlugin = this.authPlugins.get(auth.type);
-    if (authPlugin === null || authPlugin === undefined) {
-      this.logger.error(`No auth plugin registered for type: ${auth.type}`);
-      throw new Error(`No auth plugin registered for type: ${auth.type}`);
-    }
-
-    this.logger.debug(`Applying auth: ${auth.type} (plugin: ${authPlugin.name})`);
-    
-    try {
-      const pluginLogger = this.logger.createLogger(`Auth:${authPlugin.name}`);
-      return await authPlugin.apply(request, auth, options, pluginLogger);
-    } catch (error: unknown) {
-      const errorMsg = (error as { message?: string }).message ?? 'Unknown error';
-      this.logger.error(`Auth plugin error (${auth.type}): ${errorMsg}`);
-      throw new Error(`Auth plugin error (${auth.type}): ${errorMsg}`);
-    }
-  }
-
-  /**
-   * Execute request using appropriate plugin
-   * @param protocol - Protocol name from collection.protocol
-   * @param emitEvent - Optional callback for plugin events (e.g., WebSocket onMessage)
-   */
-  async execute(
-    protocol: string,
-    request: Request,
-    context: ExecutionContext,
-    options: RuntimeOptions,
-    emitEvent?: (eventName: string, eventData: unknown) => Promise<void>
-  ): Promise<ProtocolResponse> {
-    // Check abort signal before execution
-    if ((context.abortSignal as AbortSignal | undefined)?.aborted === true) {
-      this.logger.debug('Plugin execution aborted before start');
-      return {
-        status: 0,
-        statusText: 'Aborted',
-        body: '',
-        headers: {},
-        duration: 0,
-        error: 'Request aborted'
-      };
-    }
-    
-    const plugin = this.plugins.get(protocol);
-
-    if (plugin === null || plugin === undefined) {
-      this.logger.error(`No plugin registered for protocol: ${protocol}`);
-      throw new Error(`No plugin registered for protocol: ${protocol}`);
-    }
-
-    this.logger.debug(`Executing request using ${protocol} plugin: ${plugin.name}`);
-
-    // Validate auth compatibility with protocol
-    if (request.auth !== null && request.auth !== undefined && request.auth.type !== 'none' && request.auth.type !== 'inherit') {
-      if (!plugin.supportedAuthTypes.includes(request.auth.type)) {
-        this.logger.error(`Protocol '${protocol}' does not support auth type '${request.auth.type}'`);
-        throw new Error(
-          `Protocol '${protocol}' does not support auth type '${request.auth.type}'. ` +
-          `Supported types: ${plugin.supportedAuthTypes.join(', ')}`
-        );
-      }
-    }
-
-    // Apply auth if configured (should already be resolved)
-    let modifiedRequest = request;
-    if (request.auth !== null && request.auth !== undefined) {
-      modifiedRequest = await this.applyAuth(modifiedRequest, request.auth, options);
-      
-      // Update context.currentRequest to reflect auth modifications
-      context.currentRequest = modifiedRequest;
-    }
-
-    // Validate request
-    this.logger.trace('Validating request with plugin');
-    const validation = plugin.validate(modifiedRequest, options);
-    if (validation.valid === false) {
-      const errorMessages = validation.errors?.map(e => e.message).join(', ') ?? 'Unknown error';
-      this.logger.error(`Request validation failed: ${errorMessages}`);
-      throw new Error(`Request validation failed: ${errorMessages}`);
-    }
-
-    // Execute plugin with merged runtime options, event emitter, and logger
-    const pluginLogger = this.logger.createLogger(`Protocol:${plugin.name}`);
-    const response = await plugin.execute(modifiedRequest, context, options, emitEvent, pluginLogger);
-    
-    this.logger.debug(`Plugin execution completed in ${response.duration}ms (status: ${response.status})`);
-    
-    return response;
-  }
-
-  /**
-   * Get all registered plugins
-   */
-  getAllPlugins(): IProtocolPlugin[] {
-    return Array.from(this.plugins.values());
-  }
-
-  /**
-   * Get all registered auth plugins
-   */
-  getAllAuthPlugins(): IAuthPlugin[] {
-    return Array.from(this.authPlugins.values());
-  }
-
-  /**
-   * Get variable provider plugin
-   */
-  getVariableProvider(provider: string): IValueProviderPlugin | undefined {
-    return this.variableProviders.get(provider);
-  }
-
-  /**
-   * Get all registered variable providers
-   */
-  getAllVariableProviders(): IValueProviderPlugin[] {
-    return Array.from(this.variableProviders.values());
-  }
-
-  /**
-   * Resolve variable value using provider plugin
-   * Called when a variable has a provider specified
-   */
-  async resolveVariableProvider(
-    provider: string,
-    key: string,
-    config?: Record<string, unknown>,
-    context?: ExecutionContext
-  ): Promise<string | null> {
-    const providerPlugin = this.variableProviders.get(provider);
-
-    if (providerPlugin === null || providerPlugin === undefined) {
-      throw new Error(`No variable provider plugin registered for: ${provider}`);
-    }
-
-    try {
-      const providerLogger = this.logger.createLogger(`Vault:${providerPlugin.name}`);
-      return await providerPlugin.getValue(key, config, context, providerLogger);
-    } catch (error: unknown) {
-      const errorMsg = (error as { message?: string }).message ?? 'Unknown error';
-      throw new Error(`Variable provider error (${provider}): ${errorMsg}`);
-    }
-  }
-}

package/src/PluginResolver.ts

@@ -1,154 +0,0 @@
-import type { PluginPackageJson } from '@apiquest/types';
-import { Logger } from './Logger.js';
-
-export interface ResolvedPlugin {
-  name: string;
-  version: string;
-  type: 'protocol' | 'auth' | 'value';
-  path: string;
-  entryPoint: string;
-  protocols?: string[];
-  authTypes?: string[];
-  provider?: string;
-}
-
-export class PluginResolver {
-  private resolved: Map<string, ResolvedPlugin> = new Map();
-  private logger: Logger;
-
-  constructor(baseLogger?: Logger) {
-    this.logger = baseLogger?.createLogger('PluginResolver') ?? new Logger('PluginResolver');
-  }
-
-  /**
-   * Scan multiple directories and resolve all available plugins
-   * This is fast - just file I/O, no module loading
-   */
-  async scanDirectories(dirs: string[]): Promise<ResolvedPlugin[]> {
-    const scanPromises = dirs.map(dir =>
-      this.scanDirectory(dir).catch(err => {
-        this.logger.error('Plugin scanning failed:', err);
-      })
-    );
-
-    await Promise.all(scanPromises);
-
-    return Array.from(this.resolved.values());
-  }
-
-  /**
-   * Scan single directory for plugins
-   */
-  private async scanDirectory(pluginsDir: string): Promise<void> {
-    const { readdir, readFile, access } = await import('fs/promises');
-    const path = await import('path');
-
-    this.logger.debug(`Scanning plugins: ${pluginsDir}`);
-
-    // Check if directory exists
-    try {
-      await access(pluginsDir);
-    } catch {
-      this.logger.debug(`Plugins directory does not exist: ${pluginsDir}`);
-      return;
-    }
-
-    const entries = await readdir(pluginsDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      // Only process plugin-* directories
-      if (!entry.isDirectory() || !entry.name.startsWith('plugin-')) {
-        continue;
-      }
-
-      const pluginPath = path.join(pluginsDir, entry.name);
-      await this.resolvePlugin(pluginPath);
-    }
-  }
-
-  /**
-   * Resolve a single plugin - read metadata but don't load module
-   */
-  private async resolvePlugin(pluginPath: string): Promise<void> {
-    const { readFile } = await import('fs/promises');
-    const path = await import('path');
-
-    const packageJsonPath = path.join(pluginPath, 'package.json');
-
-    try {
-      // Read package.json
-      const pkgContent = await readFile(packageJsonPath, 'utf-8');
-      const pkg = JSON.parse(pkgContent) as PluginPackageJson;
-
-      // Check if plugin is for fracture runtime
-      const runtime = pkg.apiquest?.runtime;
-      const runtimeArray = Array.isArray(runtime) ? runtime : [runtime];
-      if (pkg.apiquest === null || pkg.apiquest === undefined || !runtimeArray.includes('fracture')) {
-        this.logger.debug(`Skipping ${pkg.name} (runtime: ${runtime ?? 'undefined'})`);
-        return;
-      }
-
-      // Extract metadata from package.json
-      const type = pkg.apiquest.type;
-      if (!['protocol', 'auth', 'value'].includes(type)) {
-        this.logger.warn(`Unknown plugin type: ${type} (${pkg.name})`);
-        return;
-      }
-
-      // Resolve entry point
-      const entryPoint = pkg.main ?? 'dist/index.js';
-      const fullEntryPath = path.join(pluginPath, entryPoint);
-
-      // Extract capabilities from apiquest.capabilities.provides
-      const provides = pkg.apiquest.capabilities?.provides ?? {};
-
-      // Create resolved plugin info
-      const resolved: ResolvedPlugin = {
-        name: pkg.name,
-        version: pkg.version,
-        type: type as 'protocol' | 'auth' | 'value',
-        path: pluginPath,
-        entryPoint: fullEntryPath,
-        protocols: provides.protocols,
-        authTypes: provides.authTypes,
-        provider: provides.provider,
-      };
-
-      // Check for version conflicts
-      const existing = this.resolved.get(pkg.name);
-      if (existing !== null && existing !== undefined) {
-        if (this.compareVersions(pkg.version, existing.version) > 0) {
-          this.logger.debug(`Upgrading ${pkg.name} from v${existing.version} to v${pkg.version}`);
-          this.resolved.set(pkg.name, resolved);
-        } else {
-          this.logger.debug(`Skipping ${pkg.name} v${pkg.version} (v${existing.version} already resolved)`);
-        }
-      } else {
-        this.logger.debug(`Resolved ${pkg.name} v${pkg.version} (${type})`);
-        this.resolved.set(pkg.name, resolved);
-      }
-    } catch (error: unknown) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Failed to resolve plugin at ${pluginPath}:`, errorMsg);
-    }
-  }
-
-  /**
-   * Compare semantic versions
-   * Returns: 1 if a > b, -1 if a < b, 0 if equal
-   */
-  private compareVersions(a: string, b: string): number {
-    const aParts = a.split('.').map(Number);
-    const bParts = b.split('.').map(Number);
-
-    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
-      const aNum = aParts[i] ?? 0;
-      const bNum = bParts[i] ?? 0;
-
-      if (aNum > bNum) return 1;
-      if (aNum < bNum) return -1;
-    }
-
-    return 0;
-  }
-}