@carno.js/core 1.1.1 → 1.2.0

package/src/DefaultRoutes.ts

@@ -1,34 +1,34 @@
-import { Controller } from './decorators/Controller';
-import { Get } from './decorators/methods';
-
-/**
- * Default routes controller.
- * Auto-registered by Turbo for common endpoints.
- */
-@Controller()
-export class DefaultRoutes {
-
-    /**
-     * Favicon - returns empty response to prevent 404.
-     */
-    @Get('/favicon.ico')
-    favicon() {
-        return new Response(null, { status: 204 });
-    }
-}
-
-/**
- * Pre-compiled static responses for maximum performance.
- * Use these directly in Bun.serve static routes.
- */
-export const DEFAULT_STATIC_ROUTES = {
-    '/health': new Response('{"status":"ok"}', {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' }
-    }),
-    '/ready': new Response('{"ready":true}', {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' }
-    }),
-    '/favicon.ico': new Response(null, { status: 204 })
-};
+import { Controller } from './decorators/Controller';
+import { Get } from './decorators/methods';
+
+/**
+ * Default routes controller.
+ * Auto-registered by Turbo for common endpoints.
+ */
+@Controller()
+export class DefaultRoutes {
+
+    /**
+     * Favicon - returns empty response to prevent 404.
+     */
+    @Get('/favicon.ico')
+    favicon() {
+        return new Response(null, { status: 204 });
+    }
+}
+
+/**
+ * Pre-compiled static responses for maximum performance.
+ * Use these directly in Bun.serve static routes.
+ */
+export const DEFAULT_STATIC_ROUTES = {
+    '/health': new Response('{"status":"ok"}', {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' }
+    }),
+    '/ready': new Response('{"ready":true}', {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' }
+    }),
+    '/favicon.ico': new Response(null, { status: 204 })
+};

package/src/cache/CacheDriver.ts

@@ -1,50 +1,50 @@
-/**
- * Cache Driver Interface.
- * Implement this to add new cache backends (Redis, Memcached, etc.)
- */
-export interface CacheDriver {
-    /**
-     * Driver name for debugging.
-     */
-    readonly name: string;
-
-    /**
-     * Get a value from cache.
-     */
-    get<T>(key: string): Promise<T | null>;
-
-    /**
-     * Set a value in cache.
-     * @param ttl Time to live in seconds (optional)
-     */
-    set<T>(key: string, value: T, ttl?: number): Promise<boolean>;
-
-    /**
-     * Delete a value from cache.
-     */
-    del(key: string): Promise<boolean>;
-
-    /**
-     * Check if key exists.
-     */
-    has(key: string): Promise<boolean>;
-
-    /**
-     * Clear all cached values.
-     */
-    clear(): Promise<void>;
-
-    /**
-     * Close connection (for Redis, etc.)
-     */
-    close?(): Promise<void>;
-}
-
-/**
- * Cache configuration.
- */
-export interface CacheConfig {
-    driver?: CacheDriver;
-    prefix?: string;
-    defaultTtl?: number;
-}
+/**
+ * Cache Driver Interface.
+ * Implement this to add new cache backends (Redis, Memcached, etc.)
+ */
+export interface CacheDriver {
+    /**
+     * Driver name for debugging.
+     */
+    readonly name: string;
+
+    /**
+     * Get a value from cache.
+     */
+    get<T>(key: string): Promise<T | null>;
+
+    /**
+     * Set a value in cache.
+     * @param ttl Time to live in seconds (optional)
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<boolean>;
+
+    /**
+     * Delete a value from cache.
+     */
+    del(key: string): Promise<boolean>;
+
+    /**
+     * Check if key exists.
+     */
+    has(key: string): Promise<boolean>;
+
+    /**
+     * Clear all cached values.
+     */
+    clear(): Promise<void>;
+
+    /**
+     * Close connection (for Redis, etc.)
+     */
+    close?(): Promise<void>;
+}
+
+/**
+ * Cache configuration.
+ */
+export interface CacheConfig {
+    driver?: CacheDriver;
+    prefix?: string;
+    defaultTtl?: number;
+}

package/src/cache/CacheService.ts

@@ -1,139 +1,139 @@
-import type { CacheDriver, CacheConfig } from './CacheDriver';
-import { MemoryDriver } from './MemoryDriver';
-
-/**
- * CacheService - High-performance caching with driver pattern.
- * 
- * Features:
- * - In-memory (default) or Redis backend
- * - getOrSet for cache-aside pattern
- * - Key prefixing for namespacing
- * - Configurable default TTL
- * 
- * Usage:
- * ```typescript
- * const cache = new CacheService();
- * 
- * // Basic operations
- * await cache.set('user:123', { name: 'John' }, 3600);
- * const user = await cache.get<User>('user:123');
- * 
- * // Cache-aside pattern
- * const user = await cache.getOrSet('user:123', 
- *   async () => db.findUser(123),
- *   3600
- * );
- * ```
- */
-export class CacheService {
-    private driver: CacheDriver;
-    private prefix: string;
-    private defaultTtl: number | undefined;
-
-    constructor(config: CacheConfig = {}) {
-        this.driver = config.driver || new MemoryDriver();
-        this.prefix = config.prefix || '';
-        this.defaultTtl = config.defaultTtl;
-    }
-
-    /**
-     * Get the full key with prefix.
-     */
-    private key(key: string): string {
-        return this.prefix ? `${this.prefix}:${key}` : key;
-    }
-
-    /**
-     * Get a value from cache.
-     */
-    async get<T>(key: string): Promise<T | null> {
-        return this.driver.get<T>(this.key(key));
-    }
-
-    /**
-     * Set a value in cache.
-     * @param ttl Time to live in seconds
-     */
-    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
-        return this.driver.set(this.key(key), value, ttl ?? this.defaultTtl);
-    }
-
-    /**
-     * Delete a value from cache.
-     */
-    async del(key: string): Promise<boolean> {
-        return this.driver.del(this.key(key));
-    }
-
-    /**
-     * Check if key exists.
-     */
-    async has(key: string): Promise<boolean> {
-        return this.driver.has(this.key(key));
-    }
-
-    /**
-     * Clear all cached values.
-     */
-    async clear(): Promise<void> {
-        return this.driver.clear();
-    }
-
-    /**
-     * Get value from cache or compute and store it.
-     * This is the cache-aside pattern - most commonly used method.
-     * 
-     * @param key Cache key
-     * @param cb Callback to compute value if not cached
-     * @param ttl Time to live in seconds
-     */
-    async getOrSet<T>(key: string, cb: () => Promise<T>, ttl?: number): Promise<T> {
-        const cached = await this.get<T>(key);
-
-        if (cached !== null) {
-            return cached;
-        }
-
-        const value = await cb();
-        await this.set(key, value, ttl);
-
-        return value;
-    }
-
-    /**
-     * Get multiple values at once.
-     */
-    async getMany<T>(keys: string[]): Promise<(T | null)[]> {
-        return Promise.all(keys.map(key => this.get<T>(key)));
-    }
-
-    /**
-     * Set multiple values at once.
-     */
-    async setMany<T>(entries: Array<{ key: string; value: T; ttl?: number }>): Promise<boolean[]> {
-        return Promise.all(
-            entries.map(entry => this.set(entry.key, entry.value, entry.ttl))
-        );
-    }
-
-    /**
-     * Delete multiple values at once.
-     */
-    async delMany(keys: string[]): Promise<boolean[]> {
-        return Promise.all(keys.map(key => this.del(key)));
-    }
-
-    /**
-     * Close the cache driver connection.
-     */
-    async close(): Promise<void> {
-        await this.driver.close?.();
-    }
-
-    /**
-     * Get the underlying driver (for advanced use).
-     */
-    getDriver(): CacheDriver {
-        return this.driver;
-    }
-}
+import type { CacheDriver, CacheConfig } from './CacheDriver';
+import { MemoryDriver } from './MemoryDriver';
+
+/**
+ * CacheService - High-performance caching with driver pattern.
+ * 
+ * Features:
+ * - In-memory (default) or Redis backend
+ * - getOrSet for cache-aside pattern
+ * - Key prefixing for namespacing
+ * - Configurable default TTL
+ * 
+ * Usage:
+ * ```typescript
+ * const cache = new CacheService();
+ * 
+ * // Basic operations
+ * await cache.set('user:123', { name: 'John' }, 3600);
+ * const user = await cache.get<User>('user:123');
+ * 
+ * // Cache-aside pattern
+ * const user = await cache.getOrSet('user:123', 
+ *   async () => db.findUser(123),
+ *   3600
+ * );
+ * ```
+ */
+export class CacheService {
+    private driver: CacheDriver;
+    private prefix: string;
+    private defaultTtl: number | undefined;
+
+    constructor(config: CacheConfig = {}) {
+        this.driver = config.driver || new MemoryDriver();
+        this.prefix = config.prefix || '';
+        this.defaultTtl = config.defaultTtl;
+    }
+
+    /**
+     * Get the full key with prefix.
+     */
+    private key(key: string): string {
+        return this.prefix ? `${this.prefix}:${key}` : key;
+    }
+
+    /**
+     * Get a value from cache.
+     */
+    async get<T>(key: string): Promise<T | null> {
+        return this.driver.get<T>(this.key(key));
+    }
+
+    /**
+     * Set a value in cache.
+     * @param ttl Time to live in seconds
+     */
+    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
+        return this.driver.set(this.key(key), value, ttl ?? this.defaultTtl);
+    }
+
+    /**
+     * Delete a value from cache.
+     */
+    async del(key: string): Promise<boolean> {
+        return this.driver.del(this.key(key));
+    }
+
+    /**
+     * Check if key exists.
+     */
+    async has(key: string): Promise<boolean> {
+        return this.driver.has(this.key(key));
+    }
+
+    /**
+     * Clear all cached values.
+     */
+    async clear(): Promise<void> {
+        return this.driver.clear();
+    }
+
+    /**
+     * Get value from cache or compute and store it.
+     * This is the cache-aside pattern - most commonly used method.
+     * 
+     * @param key Cache key
+     * @param cb Callback to compute value if not cached
+     * @param ttl Time to live in seconds
+     */
+    async getOrSet<T>(key: string, cb: () => Promise<T>, ttl?: number): Promise<T> {
+        const cached = await this.get<T>(key);
+
+        if (cached !== null) {
+            return cached;
+        }
+
+        const value = await cb();
+        await this.set(key, value, ttl);
+
+        return value;
+    }
+
+    /**
+     * Get multiple values at once.
+     */
+    async getMany<T>(keys: string[]): Promise<(T | null)[]> {
+        return Promise.all(keys.map(key => this.get<T>(key)));
+    }
+
+    /**
+     * Set multiple values at once.
+     */
+    async setMany<T>(entries: Array<{ key: string; value: T; ttl?: number }>): Promise<boolean[]> {
+        return Promise.all(
+            entries.map(entry => this.set(entry.key, entry.value, entry.ttl))
+        );
+    }
+
+    /**
+     * Delete multiple values at once.
+     */
+    async delMany(keys: string[]): Promise<boolean[]> {
+        return Promise.all(keys.map(key => this.del(key)));
+    }
+
+    /**
+     * Close the cache driver connection.
+     */
+    async close(): Promise<void> {
+        await this.driver.close?.();
+    }
+
+    /**
+     * Get the underlying driver (for advanced use).
+     */
+    getDriver(): CacheDriver {
+        return this.driver;
+    }
+}

package/src/cache/MemoryDriver.ts

@@ -1,104 +1,104 @@
-import type { CacheDriver } from './CacheDriver';
-
-interface CacheEntry<T> {
-    value: T;
-    expiresAt: number | null;
-}
-
-/**
- * In-Memory Cache Driver.
- * Ultra-fast, perfect for single-instance applications.
- * 
- * Features:
- * - O(1) get/set/del operations
- * - Lazy expiration (checked on access)
- * - Periodic cleanup of expired entries
- */
-export class MemoryDriver implements CacheDriver {
-    readonly name = 'MemoryDriver';
-
-    private cache = new Map<string, CacheEntry<any>>();
-    private cleanupInterval: Timer | null = null;
-
-    constructor(cleanupIntervalMs: number = 0) {
-        // Periodic cleanup of expired entries (disabled by default for performance)
-        if (cleanupIntervalMs > 0) {
-            this.cleanupInterval = setInterval(() => this.cleanup(), cleanupIntervalMs);
-        }
-    }
-
-    async get<T>(key: string): Promise<T | null> {
-        const entry = this.cache.get(key);
-
-        if (!entry) {
-            return null;
-        }
-
-        // Check expiration
-        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            return null;
-        }
-
-        return entry.value;
-    }
-
-    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
-        const expiresAt = ttl ? Date.now() + ttl : null;
-
-        this.cache.set(key, { value, expiresAt });
-
-        return true;
-    }
-
-    async del(key: string): Promise<boolean> {
-        return this.cache.delete(key);
-    }
-
-    async has(key: string): Promise<boolean> {
-        const entry = this.cache.get(key);
-
-        if (!entry) {
-            return false;
-        }
-
-        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            return false;
-        }
-
-        return true;
-    }
-
-    async clear(): Promise<void> {
-        this.cache.clear();
-    }
-
-    async close(): Promise<void> {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        this.cache.clear();
-    }
-
-    /**
-     * Remove expired entries.
-     */
-    private cleanup(): void {
-        const now = Date.now();
-
-        for (const [key, entry] of this.cache) {
-            if (entry.expiresAt !== null && now > entry.expiresAt) {
-                this.cache.delete(key);
-            }
-        }
-    }
-
-    /**
-     * Get cache stats (for debugging).
-     */
-    stats(): { size: number } {
-        return { size: this.cache.size };
-    }
-}
+import type { CacheDriver } from './CacheDriver';
+
+interface CacheEntry<T> {
+    value: T;
+    expiresAt: number | null;
+}
+
+/**
+ * In-Memory Cache Driver.
+ * Ultra-fast, perfect for single-instance applications.
+ * 
+ * Features:
+ * - O(1) get/set/del operations
+ * - Lazy expiration (checked on access)
+ * - Periodic cleanup of expired entries
+ */
+export class MemoryDriver implements CacheDriver {
+    readonly name = 'MemoryDriver';
+
+    private cache = new Map<string, CacheEntry<any>>();
+    private cleanupInterval: Timer | null = null;
+
+    constructor(cleanupIntervalMs: number = 0) {
+        // Periodic cleanup of expired entries (disabled by default for performance)
+        if (cleanupIntervalMs > 0) {
+            this.cleanupInterval = setInterval(() => this.cleanup(), cleanupIntervalMs);
+        }
+    }
+
+    async get<T>(key: string): Promise<T | null> {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return null;
+        }
+
+        // Check expiration
+        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+
+        return entry.value;
+    }
+
+    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
+        const expiresAt = ttl ? Date.now() + ttl : null;
+
+        this.cache.set(key, { value, expiresAt });
+
+        return true;
+    }
+
+    async del(key: string): Promise<boolean> {
+        return this.cache.delete(key);
+    }
+
+    async has(key: string): Promise<boolean> {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return false;
+        }
+
+        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return false;
+        }
+
+        return true;
+    }
+
+    async clear(): Promise<void> {
+        this.cache.clear();
+    }
+
+    async close(): Promise<void> {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.cache.clear();
+    }
+
+    /**
+     * Remove expired entries.
+     */
+    private cleanup(): void {
+        const now = Date.now();
+
+        for (const [key, entry] of this.cache) {
+            if (entry.expiresAt !== null && now > entry.expiresAt) {
+                this.cache.delete(key);
+            }
+        }
+    }
+
+    /**
+     * Get cache stats (for debugging).
+     */
+    stats(): { size: number } {
+        return { size: this.cache.size };
+    }
+}