triva 0.0.1 → 0.3.0

package/lib/cache.js

@@ -0,0 +1,112 @@
+/*!
+ * Triva - Cache Manager with Database Adapters
+ * Copyright (c) 2026 Kris Powers
+ * License MIT
+ */
+
+'use strict';
+
+import { createAdapter } from './db-adapters.js';
+
+/* ---------------- Cache Manager ---------------- */
+class CacheManager {
+  constructor() {
+    this.adapter = null;
+    this.config = {
+      enabled: true,
+      type: 'memory',
+      retention: 10 * 60 * 1000, // 10 minutes default
+      limit: 100000
+    };
+  }
+
+  async configure(options = {}) {
+    this.config = {
+      ...this.config,
+      enabled: options.cache_data !== false,
+      type: options.cache_type || options.type || 'memory',
+      retention: options.cache_retention || options.retention || this.config.retention,
+      limit: options.cache_limit || options.limit || this.config.limit
+    };
+
+    // Create adapter
+    try {
+      const adapterConfig = options.database || options.db || {};
+      this.adapter = createAdapter(this.config.type, adapterConfig);
+      await this.adapter.connect();
+    } catch (error) {
+      console.error('❌ Cache adapter error:', error.message);
+      throw error;
+    }
+
+    return this;
+  }
+
+  async get(key) {
+    if (!this.config.enabled || !this.adapter) return null;
+    return await this.adapter.get(key);
+  }
+
+  async set(key, value, ttl = null) {
+    if (!this.config.enabled || !this.adapter) return false;
+    const actualTtl = ttl !== null ? ttl : this.config.retention;
+    return await this.adapter.set(key, value, actualTtl);
+  }
+
+  async delete(key) {
+    if (!this.adapter) return false;
+    return await this.adapter.delete(key);
+  }
+
+  async has(key) {
+    if (!this.adapter) return false;
+    return await this.adapter.has(key);
+  }
+
+  async clear() {
+    if (!this.adapter) return 0;
+    return await this.adapter.clear();
+  }
+
+  async keys(pattern = null) {
+    if (!this.adapter) return [];
+    return await this.adapter.keys(pattern);
+  }
+
+  async size() {
+    if (!this.adapter) return 0;
+    const allKeys = await this.adapter.keys();
+    return allKeys.length;
+  }
+
+  async stats() {
+    const size = await this.size();
+    
+    return {
+      size,
+      maxSize: this.config.limit,
+      active: size,
+      config: {
+        enabled: this.config.enabled,
+        type: this.config.type,
+        retention: this.config.retention,
+        limit: this.config.limit
+      }
+    };
+  }
+
+  shutdown() {
+    if (this.adapter) {
+      this.adapter.disconnect();
+    }
+  }
+}
+
+/* ---------------- Export Singleton ---------------- */
+const cache = new CacheManager();
+
+function configCache(options) {
+  return cache.configure(options);
+}
+
+export { cache, configCache, CacheManager };

package/lib/cookie-parser.js

@@ -0,0 +1,114 @@
+/*!
+ * Triva - Cookie Parser
+ * Copyright (c) 2026 Kris Powers
+ * License MIT
+ */
+
+'use strict';
+
+/* ---------------- Cookie Parsing ---------------- */
+function parseCookies(cookieHeader) {
+  if (!cookieHeader) return {};
+  
+  const cookies = {};
+  
+  cookieHeader.split(';').forEach(cookie => {
+    const parts = cookie.trim().split('=');
+    const key = parts[0];
+    const value = parts.slice(1).join('='); // Handle values with '=' in them
+    
+    if (key) {
+      try {
+        // Decode URI components
+        cookies[key] = decodeURIComponent(value);
+      } catch (e) {
+        // If decode fails, use raw value
+        cookies[key] = value;
+      }
+    }
+  });
+  
+  return cookies;
+}
+
+/* ---------------- Cookie Serialization ---------------- */
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  
+  if (options.maxAge) {
+    cookie += `; Max-Age=${options.maxAge}`;
+  }
+  
+  if (options.expires) {
+    const expires = options.expires instanceof Date 
+      ? options.expires.toUTCString() 
+      : new Date(options.expires).toUTCString();
+    cookie += `; Expires=${expires}`;
+  }
+  
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+  
+  if (options.path) {
+    cookie += `; Path=${options.path}`;
+  } else {
+    cookie += `; Path=/`;
+  }
+  
+  if (options.secure) {
+    cookie += `; Secure`;
+  }
+  
+  if (options.httpOnly) {
+    cookie += `; HttpOnly`;
+  }
+  
+  if (options.sameSite) {
+    const sameSite = typeof options.sameSite === 'string' 
+      ? options.sameSite 
+      : (options.sameSite === true ? 'Strict' : 'Lax');
+    cookie += `; SameSite=${sameSite}`;
+  }
+  
+  return cookie;
+}
+
+/* ---------------- Cookie Parser Middleware ---------------- */
+function cookieParser(secret) {
+  return (req, res, next) => {
+    // Parse cookies from request
+    const cookieHeader = req.headers.cookie;
+    req.cookies = parseCookies(cookieHeader);
+    
+    // Add cookie helper methods to response
+    res.cookie = (name, value, options = {}) => {
+      const cookie = serializeCookie(name, value, options);
+      
+      // Handle multiple Set-Cookie headers
+      const existing = res.getHeader('Set-Cookie');
+      if (existing) {
+        const cookies = Array.isArray(existing) ? existing : [existing];
+        cookies.push(cookie);
+        res.setHeader('Set-Cookie', cookies);
+      } else {
+        res.setHeader('Set-Cookie', cookie);
+      }
+      
+      return res;
+    };
+    
+    res.clearCookie = (name, options = {}) => {
+      const clearOptions = {
+        ...options,
+        expires: new Date(0),
+        maxAge: -1
+      };
+      return res.cookie(name, '', clearOptions);
+    };
+    
+    next();
+  };
+}
+
+export { parseCookies, serializeCookie, cookieParser };