keypointjs 1.0.0

package/src/plugins/AuditLogger.js

@@ -0,0 +1,294 @@
+export class AuditLogger {
+  constructor(options = {}) {
+    this.options = {
+      logLevel: 'info',
+      logToConsole: true,
+      logToFile: false,
+      filePath: './audit.log',
+      maxFileSize: '10mb',
+      ...options
+    };
+    
+    this.levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      critical: 4
+    };
+    
+    this.logs = [];
+    this.rotationInterval = null;
+    
+    if (this.options.logToFile) {
+      this.setupFileLogging();
+    }
+  }
+  
+  async process(context, next) {
+    const startTime = Date.now();
+    
+    try {
+      // Add audit data to context
+      context.audit = {
+        requestId: context.id,
+        keypointId: context.getKeypointId(),
+        timestamp: new Date(),
+        action: `${context.method} ${context.path}`,
+        status: 'processing'
+      };
+      
+      const result = await next(context);
+      const duration = Date.now() - startTime;
+      
+      // Log successful request
+      await this.logRequest(context, {
+        status: 'success',
+        duration,
+        responseStatus: context.response?.status
+      });
+      
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      // Log failed request
+      await this.logRequest(context, {
+        status: 'error',
+        duration,
+        error: error.message,
+        errorCode: error.code,
+        stack: this.options.logLevel === 'debug' ? error.stack : undefined
+      });
+      
+      throw error;
+    }
+  }
+  
+  async logRequest(context, details = {}) {
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level: details.status === 'error' ? 'error' : 'info',
+      requestId: context.id,
+      keypointId: context.getKeypointId(),
+      ip: context.ip,
+      userAgent: context.getHeader('user-agent'),
+      method: context.method,
+      path: context.path,
+      protocol: context.protocol,
+      scopes: context.keypoint?.scopes || [],
+      ...details,
+      metadata: {
+        ...context.getKeypointMetadata(),
+        ...details.metadata
+      }
+    };
+    
+    // Add to memory buffer
+    this.logs.push(logEntry);
+    
+    // Log to console
+    if (this.options.logToConsole) {
+      this.logToConsole(logEntry);
+    }
+    
+    // Log to file
+    if (this.options.logToFile) {
+      await this.logToFile(logEntry);
+    }
+    
+    // Trigger event
+    this.emit('audit', logEntry);
+    
+    return logEntry;
+  }
+  
+  logToConsole(entry) {
+    const color = {
+      info: '\x1b[32m', // Green
+      warn: '\x1b[33m', // Yellow
+      error: '\x1b[31m', // Red
+      debug: '\x1b[36m' // Cyan
+    } [entry.level] || '\x1b[0m';
+    
+    const reset = '\x1b[0m';
+    
+    const message = [
+      `${color}[${entry.timestamp}]`,
+      `${entry.level.toUpperCase()}`,
+      `${entry.method} ${entry.path}`,
+      `${entry.status || ''}`,
+      `${entry.duration ? `${entry.duration}ms` : ''}`,
+      entry.error ? `- ${entry.error}` : '',
+      reset
+    ].filter(Boolean).join(' ');
+    
+    console.log(message);
+  }
+  
+  async logToFile(entry) {
+    const fs = await import('fs/promises');
+    
+    try {
+      const line = JSON.stringify(entry) + '\n';
+      await fs.appendFile(this.options.filePath, line, 'utf-8');
+      
+      // Check file size for rotation
+      await this.checkFileRotation();
+    } catch (error) {
+      console.error('Failed to write audit log:', error);
+    }
+  }
+  
+  async checkFileRotation() {
+    const fs = await import('fs/promises');
+    
+    try {
+      const stats = await fs.stat(this.options.filePath);
+      const maxSize = this.parseSize(this.options.maxFileSize);
+      
+      if (stats.size > maxSize) {
+        await this.rotateLogFile();
+      }
+    } catch (error) {
+      // File doesn't exist or other error
+    }
+  }
+  
+  async rotateLogFile() {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const oldPath = this.options.filePath;
+    const newPath = path.join(
+      path.dirname(oldPath),
+      `${path.basename(oldPath, '.log')}-${timestamp}.log`
+    );
+    
+    try {
+      await fs.rename(oldPath, newPath);
+      console.log(`Rotated audit log to ${newPath}`);
+    } catch (error) {
+      console.error('Failed to rotate log file:', error);
+    }
+  }
+  
+  parseSize(size) {
+    const match = size.match(/^(\d+)(mb|kb|b)$/i);
+    if (!match) return 10 * 1024 * 1024; // 10MB default
+    
+    const [, num, unit] = match;
+    const multiplier = {
+      'b': 1,
+      'kb': 1024,
+      'mb': 1024 * 1024
+    } [unit.toLowerCase()];
+    
+    return parseInt(num) * multiplier;
+  }
+  
+  setupFileLogging() {
+    // Setup periodic rotation check
+    this.rotationInterval = setInterval(() => {
+      this.checkFileRotation();
+    }, 60000); // Check every minute
+    
+    // Ensure log directory exists
+    this.ensureLogDirectory();
+  }
+  
+  async ensureLogDirectory() {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    
+    const dir = path.dirname(this.options.filePath);
+    
+    try {
+      await fs.access(dir);
+    } catch {
+      await fs.mkdir(dir, { recursive: true });
+    }
+  }
+  
+  async queryLogs(filter = {}) {
+    let filtered = this.logs;
+    
+    if (filter.startDate) {
+      const start = new Date(filter.startDate);
+      filtered = filtered.filter(log => new Date(log.timestamp) >= start);
+    }
+    
+    if (filter.endDate) {
+      const end = new Date(filter.endDate);
+      filtered = filtered.filter(log => new Date(log.timestamp) <= end);
+    }
+    
+    if (filter.level) {
+      filtered = filtered.filter(log => log.level === filter.level);
+    }
+    
+    if (filter.keypointId) {
+      filtered = filtered.filter(log => log.keypointId === filter.keypointId);
+    }
+    
+    if (filter.ip) {
+      filtered = filtered.filter(log => log.ip === filter.ip);
+    }
+    
+    if (filter.method) {
+      filtered = filtered.filter(log => log.method === filter.method);
+    }
+    
+    if (filter.path) {
+      filtered = filtered.filter(log => log.path.includes(filter.path));
+    }
+    
+    // Sort and limit
+    filtered.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    
+    if (filter.limit) {
+      filtered = filtered.slice(0, filter.limit);
+    }
+    
+    return {
+      total: this.logs.length,
+      filtered: filtered.length,
+      logs: filtered
+    };
+  }
+  
+  clearLogs() {
+    const count = this.logs.length;
+    this.logs = [];
+    return count;
+  }
+  
+  // Event emitter methods
+  on(event, handler) {
+    if (!this.listeners) this.listeners = new Map();
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event).push(handler);
+  }
+  
+  emit(event, data) {
+    if (!this.listeners || !this.listeners.has(event)) return;
+    
+    for (const handler of this.listeners.get(event)) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`Error in audit event handler:`, error);
+      }
+    }
+  }
+  
+  // Cleanup
+  cleanup() {
+    if (this.rotationInterval) {
+      clearInterval(this.rotationInterval);
+    }
+  }
+}

package/src/plugins/PluginManager.js

@@ -0,0 +1,303 @@
+export class PluginManager {
+  constructor() {
+    this.plugins = new Map();
+    this.middlewareChain = [];
+    this.events = new Map();
+    this.hooks = new Map();
+  }
+  
+  register(plugin, options = {}) {
+    const pluginName = plugin.constructor.name;
+    
+    if (this.plugins.has(pluginName)) {
+      throw new Error(`Plugin ${pluginName} already registered`);
+    }
+    
+    // Initialize plugin
+    plugin.name = pluginName;
+    plugin.options = options;
+    plugin.enabled = true;
+    
+    this.plugins.set(pluginName, plugin);
+    
+    // Add plugin's middleware if it has process method
+    if (typeof plugin.process === 'function') {
+      this.middlewareChain.push(async (ctx, next) => {
+        if (!plugin.enabled) return next(ctx);
+        return plugin.process(ctx, next);
+      });
+    }
+    
+    // Register plugin events
+    if (typeof plugin.on === 'function') {
+      plugin.on('*', (event, data) => {
+        this.emit(event, data);
+      });
+    }
+    
+    // Setup hooks
+    if (plugin.hooks) {
+      for (const [hookName, hookFn] of Object.entries(plugin.hooks)) {
+        this.addHook(hookName, hookFn);
+      }
+    }
+    
+    console.log(`Plugin registered: ${pluginName}`);
+    return this;
+  }
+  
+  unregister(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return false;
+    
+    // Remove middleware
+    const index = this.middlewareChain.findIndex(middleware => {
+      // Find middleware that uses this plugin
+      return middleware.toString().includes(pluginName);
+    });
+    
+    if (index !== -1) {
+      this.middlewareChain.splice(index, 1);
+    }
+    
+    // Cleanup plugin
+    if (typeof plugin.cleanup === 'function') {
+      plugin.cleanup();
+    }
+    
+    this.plugins.delete(pluginName);
+    console.log(`Plugin unregistered: ${pluginName}`);
+    return true;
+  }
+  
+  enable(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (plugin) {
+      plugin.enabled = true;
+      return true;
+    }
+    return false;
+  }
+  
+  disable(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (plugin) {
+      plugin.enabled = false;
+      return true;
+    }
+    return false;
+  }
+  
+  async process(context, next) {
+    // Run through plugin middleware chain
+    let index = 0;
+    
+    const runNext = async () => {
+      if (index >= this.middlewareChain.length) {
+        return next(context);
+      }
+      
+      const middleware = this.middlewareChain[index];
+      index++;
+      
+      return middleware(context, runNext);
+    };
+    
+    return runNext();
+  }
+  
+  // Event system
+  on(event, handler) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(handler);
+    return this;
+  }
+  
+  off(event, handler) {
+    if (!this.events.has(event)) return;
+    
+    const handlers = this.events.get(event);
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+    return this;
+  }
+  
+  emit(event, data) {
+    if (!this.events.has(event)) return;
+    
+    const handlers = this.events.get(event);
+    for (const handler of handlers) {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`Error in event handler for ${event}:`, error);
+      }
+    }
+    
+    // Also emit to wildcard handlers
+    if (this.events.has('*')) {
+      const wildcardHandlers = this.events.get('*');
+      for (const handler of wildcardHandlers) {
+        try {
+          handler(event, data);
+        } catch (error) {
+          console.error(`Error in wildcard event handler:`, error);
+        }
+      }
+    }
+  }
+  
+  // Hook system
+  addHook(hookName, hookFn) {
+    if (!this.hooks.has(hookName)) {
+      this.hooks.set(hookName, []);
+    }
+    this.hooks.get(hookName).push(hookFn);
+    return this;
+  }
+  
+  async runHook(hookName, ...args) {
+    if (!this.hooks.has(hookName)) return [];
+    
+    const results = [];
+    const hooks = this.hooks.get(hookName);
+    
+    for (const hookFn of hooks) {
+      try {
+        const result = await hookFn(...args);
+        if (result !== undefined) {
+          results.push(result);
+        }
+      } catch (error) {
+        console.error(`Error in hook ${hookName}:`, error);
+      }
+    }
+    
+    return results;
+  }
+  
+  // Plugin management
+  getPlugin(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  
+  getPluginNames() {
+    return Array.from(this.plugins.keys());
+  }
+  
+  getEnabledPlugins() {
+    return Array.from(this.plugins.values()).filter(p => p.enabled);
+  }
+  
+  // Configuration
+  configurePlugin(pluginName, config) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return false;
+    
+    if (typeof plugin.configure === 'function') {
+      plugin.configure(config);
+      return true;
+    }
+    
+    // Merge options if no configure method
+    plugin.options = { ...plugin.options, ...config };
+    return true;
+  }
+  
+  // Statistics
+  getStats() {
+    return {
+      totalPlugins: this.plugins.size,
+      enabledPlugins: this.getEnabledPlugins().length,
+      disabledPlugins: this.plugins.size - this.getEnabledPlugins().length,
+      middlewareCount: this.middlewareChain.length,
+      eventCount: Array.from(this.events.values()).reduce((sum, handlers) => sum + handlers.length, 0),
+      hookCount: Array.from(this.hooks.values()).reduce((sum, hooks) => sum + hooks.length, 0),
+      plugins: this.getAllPlugins().map(p => ({
+        name: p.name,
+        enabled: p.enabled,
+        hasProcess: typeof p.process === 'function',
+        hasCleanup: typeof p.cleanup === 'function'
+      }))
+    };
+  }
+  
+  // Lifecycle
+  async initialize() {
+    // Run initialization hooks
+    await this.runHook('initialize', this);
+    
+    // Initialize all plugins
+    for (const plugin of this.plugins.values()) {
+      if (typeof plugin.initialize === 'function') {
+        try {
+          await plugin.initialize();
+          console.log(`Plugin initialized: ${plugin.name}`);
+        } catch (error) {
+          console.error(`Failed to initialize plugin ${plugin.name}:`, error);
+        }
+      }
+    }
+    
+    this.emit('initialized', { timestamp: new Date() });
+  }
+  
+  async shutdown() {
+    // Run shutdown hooks
+    await this.runHook('shutdown', this);
+    
+    // Shutdown all plugins
+    for (const plugin of this.plugins.values()) {
+      if (typeof plugin.shutdown === 'function') {
+        try {
+          await plugin.shutdown();
+          console.log(`Plugin shutdown: ${plugin.name}`);
+        } catch (error) {
+          console.error(`Failed to shutdown plugin ${plugin.name}:`, error);
+        }
+      }
+    }
+    
+    this.emit('shutdown', { timestamp: new Date() });
+    this.clear();
+  }
+  
+  clear() {
+    this.plugins.clear();
+    this.middlewareChain = [];
+    this.events.clear();
+    this.hooks.clear();
+  }
+}
+
+// Built-in hooks
+export const BuiltInHooks = {
+  // Request lifecycle hooks
+  BEFORE_KEYPOINT_VALIDATION: 'before_keypoint_validation',
+  AFTER_KEYPOINT_VALIDATION: 'after_keypoint_validation',
+  BEFORE_POLICY_CHECK: 'before_policy_check',
+  AFTER_POLICY_CHECK: 'after_policy_check',
+  BEFORE_ROUTE_EXECUTION: 'before_route_execution',
+  AFTER_ROUTE_EXECUTION: 'after_route_execution',
+  BEFORE_RESPONSE: 'before_response',
+  AFTER_RESPONSE: 'after_response',
+  
+  // Error hooks
+  ON_ERROR: 'on_error',
+  
+  // Plugin lifecycle hooks
+  PLUGIN_REGISTERED: 'plugin_registered',
+  PLUGIN_UNREGISTERED: 'plugin_unregistered',
+  
+  // System hooks
+  INITIALIZE: 'initialize',
+  SHUTDOWN: 'shutdown'
+};

package/src/plugins/RateLimiter.js

@@ -0,0 +1,24 @@
+export class RateLimiter {
+  constructor(options = {}) {
+    this.limits = new Map();
+    this.window = options.window || 60 * 1000; // 1 minute
+  }
+  
+  async process(context, next) {
+    const { keypoint, request } = context;
+    
+    if (!keypoint) return next(context);
+    
+    const limitKey = `rate:${keypoint.keyId}:${Date.now() / this.window}`;
+    
+    const current = this.limits.get(limitKey) || 0;
+    const limit = keypoint.rateLimit.requests;
+    
+    if (current >= limit) {
+      throw new Error('Rate limit exceeded', 429);
+    }
+    
+    this.limits.set(limitKey, current + 1);
+    return next(context);
+  }
+}