navis.js 3.1.0 → 5.0.0

package/src/cache/cache.js

@@ -0,0 +1,157 @@
+/**
+ * In-Memory Cache
+ * v5: Simple in-memory caching with TTL support
+ */
+
+class Cache {
+  constructor(options = {}) {
+    this.store = new Map();
+    this.maxSize = options.maxSize || 1000;
+    this.defaultTTL = options.defaultTTL || 3600000; // 1 hour in ms
+    this.cleanupInterval = options.cleanupInterval || 60000; // 1 minute
+    
+    // Start cleanup interval
+    this.intervalId = setInterval(() => {
+      this._cleanup();
+    }, this.cleanupInterval);
+  }
+
+  /**
+   * Set a value in cache
+   * @param {string} key - Cache key
+   * @param {*} value - Value to cache
+   * @param {number} ttl - Time to live in milliseconds
+   */
+  set(key, value, ttl = null) {
+    const expiration = Date.now() + (ttl || this.defaultTTL);
+    
+    // Remove oldest entries if at max size
+    if (this.store.size >= this.maxSize && !this.store.has(key)) {
+      this._evictOldest();
+    }
+    
+    this.store.set(key, {
+      value,
+      expiration,
+    });
+  }
+
+  /**
+   * Get a value from cache
+   * @param {string} key - Cache key
+   * @returns {*} - Cached value or null
+   */
+  get(key) {
+    const entry = this.store.get(key);
+    
+    if (!entry) {
+      return null;
+    }
+    
+    // Check if expired
+    if (Date.now() > entry.expiration) {
+      this.store.delete(key);
+      return null;
+    }
+    
+    return entry.value;
+  }
+
+  /**
+   * Check if key exists in cache
+   * @param {string} key - Cache key
+   * @returns {boolean} - True if key exists and not expired
+   */
+  has(key) {
+    const entry = this.store.get(key);
+    
+    if (!entry) {
+      return false;
+    }
+    
+    if (Date.now() > entry.expiration) {
+      this.store.delete(key);
+      return false;
+    }
+    
+    return true;
+  }
+
+  /**
+   * Delete a key from cache
+   * @param {string} key - Cache key
+   * @returns {boolean} - True if key was deleted
+   */
+  delete(key) {
+    return this.store.delete(key);
+  }
+
+  /**
+   * Clear all cache entries
+   */
+  clear() {
+    this.store.clear();
+  }
+
+  /**
+   * Get cache size
+   * @returns {number} - Number of entries
+   */
+  size() {
+    return this.store.size;
+  }
+
+  /**
+   * Get all keys
+   * @returns {Array} - Array of cache keys
+   */
+  keys() {
+    return Array.from(this.store.keys());
+  }
+
+  /**
+   * Cleanup expired entries
+   * @private
+   */
+  _cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now > entry.expiration) {
+        this.store.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Evict oldest entry (LRU-like)
+   * @private
+   */
+  _evictOldest() {
+    let oldestKey = null;
+    let oldestExpiration = Infinity;
+    
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiration < oldestExpiration) {
+        oldestExpiration = entry.expiration;
+        oldestKey = key;
+      }
+    }
+    
+    if (oldestKey) {
+      this.store.delete(oldestKey);
+    }
+  }
+
+  /**
+   * Destroy cache (cleanup)
+   */
+  destroy() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+    this.clear();
+  }
+}
+
+module.exports = Cache;
+

package/src/cache/redis-cache.js

@@ -0,0 +1,174 @@
+/**
+ * Redis Cache Adapter
+ * v5: Redis-based caching (requires redis package)
+ */
+
+class RedisCache {
+  constructor(options = {}) {
+    this.client = null;
+    this.defaultTTL = options.defaultTTL || 3600; // 1 hour in seconds
+    this.prefix = options.prefix || 'navis:';
+    this.connected = false;
+    
+    // Try to require redis (optional dependency)
+    try {
+      const redis = require('redis');
+      this.redis = redis;
+    } catch (error) {
+      throw new Error('Redis package not installed. Install with: npm install redis');
+    }
+  }
+
+  /**
+   * Connect to Redis
+   * @param {Object} options - Redis connection options
+   */
+  async connect(options = {}) {
+    if (this.connected && this.client) {
+      return;
+    }
+
+    const {
+      url = process.env.REDIS_URL || 'redis://localhost:6379',
+      socket = {},
+      ...otherOptions
+    } = options;
+
+    this.client = this.redis.createClient({
+      url,
+      socket: {
+        reconnectStrategy: (retries) => {
+          if (retries > 10) {
+            return new Error('Too many reconnection attempts');
+          }
+          return Math.min(retries * 100, 3000);
+        },
+        ...socket,
+      },
+      ...otherOptions,
+    });
+
+    this.client.on('error', (err) => {
+      console.error('Redis Client Error:', err);
+    });
+
+    await this.client.connect();
+    this.connected = true;
+  }
+
+  /**
+   * Disconnect from Redis
+   */
+  async disconnect() {
+    if (this.client && this.connected) {
+      await this.client.quit();
+      this.connected = false;
+    }
+  }
+
+  /**
+   * Set a value in cache
+   * @param {string} key - Cache key
+   * @param {*} value - Value to cache
+   * @param {number} ttl - Time to live in seconds
+   */
+  async set(key, value, ttl = null) {
+    if (!this.connected) {
+      throw new Error('Redis not connected. Call connect() first.');
+    }
+
+    const fullKey = this.prefix + key;
+    const serialized = JSON.stringify(value);
+    const expiration = ttl || this.defaultTTL;
+
+    if (expiration > 0) {
+      await this.client.setEx(fullKey, expiration, serialized);
+    } else {
+      await this.client.set(fullKey, serialized);
+    }
+  }
+
+  /**
+   * Get a value from cache
+   * @param {string} key - Cache key
+   * @returns {*} - Cached value or null
+   */
+  async get(key) {
+    if (!this.connected) {
+      throw new Error('Redis not connected. Call connect() first.');
+    }
+
+    const fullKey = this.prefix + key;
+    const serialized = await this.client.get(fullKey);
+
+    if (!serialized) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(serialized);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check if key exists in cache
+   * @param {string} key - Cache key
+   * @returns {boolean} - True if key exists
+   */
+  async has(key) {
+    if (!this.connected) {
+      return false;
+    }
+
+    const fullKey = this.prefix + key;
+    const exists = await this.client.exists(fullKey);
+    return exists === 1;
+  }
+
+  /**
+   * Delete a key from cache
+   * @param {string} key - Cache key
+   * @returns {boolean} - True if key was deleted
+   */
+  async delete(key) {
+    if (!this.connected) {
+      return false;
+    }
+
+    const fullKey = this.prefix + key;
+    const result = await this.client.del(fullKey);
+    return result > 0;
+  }
+
+  /**
+   * Clear all cache entries with prefix
+   */
+  async clear() {
+    if (!this.connected) {
+      return;
+    }
+
+    const keys = await this.client.keys(this.prefix + '*');
+    if (keys.length > 0) {
+      await this.client.del(keys);
+    }
+  }
+
+  /**
+   * Get cache size (approximate)
+   * @returns {number} - Number of keys with prefix
+   */
+  async size() {
+    if (!this.connected) {
+      return 0;
+    }
+
+    const keys = await this.client.keys(this.prefix + '*');
+    return keys.length;
+  }
+}
+
+module.exports = RedisCache;
+

package/src/core/advanced-router.js

@@ -0,0 +1,186 @@
+/**
+ * Advanced Router with Parameters and Path Matching
+ * v4: Support for route parameters, wildcards, and path matching
+ */
+
+class AdvancedRouter {
+  constructor() {
+    this.routes = {
+      GET: [],
+      POST: [],
+      PUT: [],
+      DELETE: [],
+      PATCH: [],
+    };
+  }
+
+  /**
+   * Register a route handler
+   * @param {string} method - HTTP method
+   * @param {string} path - Route path (supports :param and * wildcards)
+   * @param {Function} handler - Route handler function
+   */
+  register(method, path, handler) {
+    const normalizedMethod = method.toUpperCase();
+    if (!this.routes[normalizedMethod]) {
+      throw new Error(`Unsupported HTTP method: ${method}`);
+    }
+
+    // Parse route pattern
+    const pattern = this._parsePattern(path);
+    
+    this.routes[normalizedMethod].push({
+      pattern: path,
+      regex: pattern.regex,
+      params: pattern.params,
+      handler,
+    });
+
+    // Sort routes by specificity (more specific first)
+    this.routes[normalizedMethod].sort((a, b) => {
+      const aSpecificity = this._calculateSpecificity(a.pattern);
+      const bSpecificity = this._calculateSpecificity(b.pattern);
+      return bSpecificity - aSpecificity;
+    });
+  }
+
+  /**
+   * Find route handler for a method and path
+   * @param {string} method - HTTP method
+   * @param {string} path - Request path
+   * @returns {Object|null} - { handler, params } or null if not found
+   */
+  find(method, path) {
+    const normalizedMethod = method.toUpperCase();
+    const methodRoutes = this.routes[normalizedMethod] || [];
+
+    for (const route of methodRoutes) {
+      const match = path.match(route.regex);
+      if (match) {
+        // Extract parameters
+        const params = {};
+        route.params.forEach((param, index) => {
+          params[param] = match[index + 1];
+        });
+
+        return {
+          handler: route.handler,
+          params,
+        };
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Parse route pattern into regex and parameter names
+   * @private
+   */
+  _parsePattern(pattern) {
+    const params = [];
+    const parts = pattern.split('/').filter(p => p !== ''); // Remove empty parts
+    const regexParts = [];
+    
+    for (const part of parts) {
+      if (part.startsWith(':')) {
+        // Parameter
+        const paramName = part.substring(1);
+        params.push(paramName);
+        regexParts.push('([^/]+)');
+      } else if (part === '*') {
+        // Wildcard
+        regexParts.push('.*');
+      } else {
+        // Literal - escape regex special chars
+        regexParts.push(part.replace(/[.+?^${}()|[\]\\]/g, '\\$&'));
+      }
+    }
+    
+    // Build regex pattern
+    const regexPattern = '^/' + regexParts.join('/') + '/?$';
+
+    return {
+      regex: new RegExp(regexPattern),
+      params,
+    };
+  }
+
+  /**
+   * Calculate route specificity (higher = more specific)
+   * @private
+   */
+  _calculateSpecificity(pattern) {
+    let specificity = 0;
+    
+    // Count static segments
+    const staticSegments = pattern.split('/').filter(seg => 
+      seg && !seg.startsWith(':') && seg !== '*'
+    );
+    specificity += staticSegments.length * 10;
+
+    // Count parameters (less specific)
+    const params = (pattern.match(/:[^/]+/g) || []).length;
+    specificity += params * 5;
+
+    // Wildcards are least specific
+    if (pattern.includes('*')) {
+      specificity -= 10;
+    }
+
+    return specificity;
+  }
+
+  /**
+   * Get all registered routes
+   * @returns {Object} - All routes grouped by method
+   */
+  getAllRoutes() {
+    const allRoutes = {};
+    for (const method in this.routes) {
+      allRoutes[method] = this.routes[method].map(route => ({
+        pattern: route.pattern,
+        params: route.params,
+      }));
+    }
+    return allRoutes;
+  }
+
+  /**
+   * Register GET route
+   */
+  get(path, handler) {
+    this.register('GET', path, handler);
+  }
+
+  /**
+   * Register POST route
+   */
+  post(path, handler) {
+    this.register('POST', path, handler);
+  }
+
+  /**
+   * Register PUT route
+   */
+  put(path, handler) {
+    this.register('PUT', path, handler);
+  }
+
+  /**
+   * Register DELETE route
+   */
+  delete(path, handler) {
+    this.register('DELETE', path, handler);
+  }
+
+  /**
+   * Register PATCH route
+   */
+  patch(path, handler) {
+    this.register('PATCH', path, handler);
+  }
+}
+
+module.exports = AdvancedRouter;
+