@carno.js/core 1.1.1 → 1.2.0

package/src/cache/RedisDriver.ts

@@ -1,116 +1,116 @@
-import type { CacheDriver } from './CacheDriver';
-
-/**
- * Redis Cache Driver Configuration.
- */
-export interface RedisConfig {
-    host?: string;
-    port?: number;
-    password?: string;
-    db?: number;
-    url?: string;
-}
-
-/**
- * Redis Cache Driver.
- * For distributed caching in multi-instance deployments.
- * 
- * Uses Bun's native Redis client for maximum performance.
- */
-export class RedisDriver implements CacheDriver {
-    readonly name = 'RedisDriver';
-
-    private client: any = null;
-    private connected = false;
-
-    constructor(private config: RedisConfig = {}) { }
-
-    /**
-     * Connect to Redis (lazy - connects on first use).
-     */
-    private async ensureConnected(): Promise<void> {
-        if (this.connected) return;
-
-        const url = this.config.url ||
-            `redis://${this.config.host || 'localhost'}:${this.config.port || 6379}`;
-
-        // Use Bun's native Redis client if available
-        if (typeof Bun !== 'undefined' && (Bun as any).redis) {
-            this.client = new (Bun as any).redis(url);
-        } else {
-            // Fallback to ioredis
-            try {
-                const Redis = require('ioredis');
-                this.client = new Redis({
-                    host: this.config.host || 'localhost',
-                    port: this.config.port || 6379,
-                    password: this.config.password,
-                    db: this.config.db || 0
-                });
-            } catch {
-                throw new Error('Redis client not available. Install ioredis or use Bun with Redis support.');
-            }
-        }
-
-        this.connected = true;
-    }
-
-    async get<T>(key: string): Promise<T | null> {
-        await this.ensureConnected();
-
-        const value = await this.client.get(key);
-
-        if (value === null) {
-            return null;
-        }
-
-        try {
-            return JSON.parse(value);
-        } catch {
-            return value as T;
-        }
-    }
-
-    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
-        await this.ensureConnected();
-
-        const serialized = typeof value === 'string' ? value : JSON.stringify(value);
-
-        if (ttl) {
-            await this.client.setex(key, ttl, serialized);
-        } else {
-            await this.client.set(key, serialized);
-        }
-
-        return true;
-    }
-
-    async del(key: string): Promise<boolean> {
-        await this.ensureConnected();
-
-        const result = await this.client.del(key);
-
-        return result > 0;
-    }
-
-    async has(key: string): Promise<boolean> {
-        await this.ensureConnected();
-
-        const result = await this.client.exists(key);
-
-        return result > 0;
-    }
-
-    async clear(): Promise<void> {
-        await this.ensureConnected();
-
-        await this.client.flushdb();
-    }
-
-    async close(): Promise<void> {
-        if (this.client && this.connected) {
-            await this.client.quit?.();
-            this.connected = false;
-        }
-    }
-}
+import type { CacheDriver } from './CacheDriver';
+
+/**
+ * Redis Cache Driver Configuration.
+ */
+export interface RedisConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    url?: string;
+}
+
+/**
+ * Redis Cache Driver.
+ * For distributed caching in multi-instance deployments.
+ * 
+ * Uses Bun's native Redis client for maximum performance.
+ */
+export class RedisDriver implements CacheDriver {
+    readonly name = 'RedisDriver';
+
+    private client: any = null;
+    private connected = false;
+
+    constructor(private config: RedisConfig = {}) { }
+
+    /**
+     * Connect to Redis (lazy - connects on first use).
+     */
+    private async ensureConnected(): Promise<void> {
+        if (this.connected) return;
+
+        const url = this.config.url ||
+            `redis://${this.config.host || 'localhost'}:${this.config.port || 6379}`;
+
+        // Use Bun's native Redis client if available
+        if (typeof Bun !== 'undefined' && (Bun as any).redis) {
+            this.client = new (Bun as any).redis(url);
+        } else {
+            // Fallback to ioredis
+            try {
+                const Redis = require('ioredis');
+                this.client = new Redis({
+                    host: this.config.host || 'localhost',
+                    port: this.config.port || 6379,
+                    password: this.config.password,
+                    db: this.config.db || 0
+                });
+            } catch {
+                throw new Error('Redis client not available. Install ioredis or use Bun with Redis support.');
+            }
+        }
+
+        this.connected = true;
+    }
+
+    async get<T>(key: string): Promise<T | null> {
+        await this.ensureConnected();
+
+        const value = await this.client.get(key);
+
+        if (value === null) {
+            return null;
+        }
+
+        try {
+            return JSON.parse(value);
+        } catch {
+            return value as T;
+        }
+    }
+
+    async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
+        await this.ensureConnected();
+
+        const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+
+        if (ttl) {
+            await this.client.setex(key, ttl, serialized);
+        } else {
+            await this.client.set(key, serialized);
+        }
+
+        return true;
+    }
+
+    async del(key: string): Promise<boolean> {
+        await this.ensureConnected();
+
+        const result = await this.client.del(key);
+
+        return result > 0;
+    }
+
+    async has(key: string): Promise<boolean> {
+        await this.ensureConnected();
+
+        const result = await this.client.exists(key);
+
+        return result > 0;
+    }
+
+    async clear(): Promise<void> {
+        await this.ensureConnected();
+
+        await this.client.flushdb();
+    }
+
+    async close(): Promise<void> {
+        if (this.client && this.connected) {
+            await this.client.quit?.();
+            this.connected = false;
+        }
+    }
+}

package/src/compiler/JITCompiler.ts

@@ -1,167 +1,167 @@
-/**
- * JIT Compiler for Turbo.
- * 
- * Aggressive AOT optimizations:
- * - Detects async at compile time (not runtime)
- * - Generates specialized handlers via new Function()
- * - Inlines parameter access
- * - Zero overhead for simple handlers
- */
-
-import type { ParamType } from '../decorators/params';
-
-export interface ParamInfo {
-    type: ParamType;
-    key?: string;
-    index: number;
-}
-
-export interface CompiledHandler {
-    fn: Function;
-    isAsync: boolean;
-    isStatic: boolean;
-    staticValue?: any;
-}
-
-const ASYNC_REGEX = /^async\s|^\([^)]*\)\s*=>\s*\{[\s\S]*await\s|^function\s*\*|\.then\s*\(/;
-
-/**
- * Detects if function is async at compile time.
- * Checks: async keyword, await usage, generators, .then()
- */
-export function isAsyncFunction(fn: Function): boolean {
-    if (fn.constructor.name === 'AsyncFunction') {
-        return true;
-    }
-
-    const source = fn.toString();
-
-    return ASYNC_REGEX.test(source);
-}
-
-/**
- * Detects if handler returns a static value.
- * Static handlers can be pre-computed at startup.
- */
-export function isStaticHandler(fn: Function): boolean {
-    const source = fn.toString();
-
-    if (source.includes('this.') || source.includes('await')) {
-        return false;
-    }
-
-    const returnMatch = source.match(/=>\s*["'`]|return\s+["'`]|=>\s*\{|=>\s*\d/);
-
-    return !!returnMatch;
-}
-
-/**
- * Compiles handler with inlined parameter access.
- * Uses new Function() for maximum V8 optimization.
- */
-export function compileHandler(
-    instance: any,
-    methodName: string,
-    params: ParamInfo[]
-): CompiledHandler {
-    const method = instance[methodName];
-    const bound = method.bind(instance);
-    const async = isAsyncFunction(method);
-
-    if (params.length === 0) {
-        const isStatic = isStaticHandler(method);
-
-        if (isStatic && !async) {
-            const staticValue = bound();
-
-            return {
-                fn: bound,
-                isAsync: false,
-                isStatic: true,
-                staticValue
-            };
-        }
-
-        return {
-            fn: bound,
-            isAsync: async,
-            isStatic: false
-        };
-    }
-
-    const argExprs = params
-        .sort((a, b) => a.index - b.index)
-        .map(p => buildArgExpression(p));
-
-    const argsCode = argExprs.join(',');
-    const hasBody = params.some(p => p.type === 'body');
-
-    if (hasBody) {
-        const code = `return async function(c){
-await c.parseBody();
-return h(${argsCode});
-}`;
-
-        return {
-            fn: new Function('h', code)(bound),
-            isAsync: true,
-            isStatic: false
-        };
-    }
-
-    if (async) {
-        const code = `return async function(c){
-return await h(${argsCode});
-}`;
-
-        return {
-            fn: new Function('h', code)(bound),
-            isAsync: true,
-            isStatic: false
-        };
-    }
-
-    const code = `return function(c){
-return h(${argsCode});
-}`;
-
-    return {
-        fn: new Function('h', code)(bound),
-        isAsync: false,
-        isStatic: false
-    };
-}
-
-function escapeKey(key: string): string {
-    return key.replace(/['\"\\]/g, '\\$&');
-}
-
-function buildArgExpression(param: ParamInfo): string {
-    const key = param.key ? escapeKey(param.key) : undefined;
-
-    switch (param.type) {
-        case 'param':
-            return key ? `c.params['${key}']` : 'c.params';
-
-        case 'query':
-            return key ? `c.query['${key}']` : 'c.query';
-
-        case 'body':
-            return key ? `c.body['${key}']` : 'c.body';
-
-        case 'header':
-            return key ? `c.req.headers.get('${key}')` : 'c.req.headers';
-
-        case 'req':
-            return 'c.req';
-
-        case 'ctx':
-            return 'c';
-
-        case 'locals':
-            return key ? `c.locals['${key}']` : 'c.locals';
-
-        default:
-            return 'undefined';
-    }
-}
+/**
+ * JIT Compiler for Turbo.
+ * 
+ * Aggressive AOT optimizations:
+ * - Detects async at compile time (not runtime)
+ * - Generates specialized handlers via new Function()
+ * - Inlines parameter access
+ * - Zero overhead for simple handlers
+ */
+
+import type { ParamType } from '../decorators/params';
+
+export interface ParamInfo {
+    type: ParamType;
+    key?: string;
+    index: number;
+}
+
+export interface CompiledHandler {
+    fn: Function;
+    isAsync: boolean;
+    isStatic: boolean;
+    staticValue?: any;
+}
+
+const ASYNC_REGEX = /^async\s|^\([^)]*\)\s*=>\s*\{[\s\S]*await\s|^function\s*\*|\.then\s*\(/;
+
+/**
+ * Detects if function is async at compile time.
+ * Checks: async keyword, await usage, generators, .then()
+ */
+export function isAsyncFunction(fn: Function): boolean {
+    if (fn.constructor.name === 'AsyncFunction') {
+        return true;
+    }
+
+    const source = fn.toString();
+
+    return ASYNC_REGEX.test(source);
+}
+
+/**
+ * Detects if handler returns a static value.
+ * Static handlers can be pre-computed at startup.
+ */
+export function isStaticHandler(fn: Function): boolean {
+    const source = fn.toString();
+
+    if (source.includes('this.') || source.includes('await')) {
+        return false;
+    }
+
+    const returnMatch = source.match(/=>\s*["'`]|return\s+["'`]|=>\s*\{|=>\s*\d/);
+
+    return !!returnMatch;
+}
+
+/**
+ * Compiles handler with inlined parameter access.
+ * Uses new Function() for maximum V8 optimization.
+ */
+export function compileHandler(
+    instance: any,
+    methodName: string,
+    params: ParamInfo[]
+): CompiledHandler {
+    const method = instance[methodName];
+    const bound = method.bind(instance);
+    const async = isAsyncFunction(method);
+
+    if (params.length === 0) {
+        const isStatic = isStaticHandler(method);
+
+        if (isStatic && !async) {
+            const staticValue = bound();
+
+            return {
+                fn: bound,
+                isAsync: false,
+                isStatic: true,
+                staticValue
+            };
+        }
+
+        return {
+            fn: bound,
+            isAsync: async,
+            isStatic: false
+        };
+    }
+
+    const argExprs = params
+        .sort((a, b) => a.index - b.index)
+        .map(p => buildArgExpression(p));
+
+    const argsCode = argExprs.join(',');
+    const hasBody = params.some(p => p.type === 'body');
+
+    if (hasBody) {
+        const code = `return async function(c){
+await c.parseBody();
+return h(${argsCode});
+}`;
+
+        return {
+            fn: new Function('h', code)(bound),
+            isAsync: true,
+            isStatic: false
+        };
+    }
+
+    if (async) {
+        const code = `return async function(c){
+return await h(${argsCode});
+}`;
+
+        return {
+            fn: new Function('h', code)(bound),
+            isAsync: true,
+            isStatic: false
+        };
+    }
+
+    const code = `return function(c){
+return h(${argsCode});
+}`;
+
+    return {
+        fn: new Function('h', code)(bound),
+        isAsync: false,
+        isStatic: false
+    };
+}
+
+function escapeKey(key: string): string {
+    return key.replace(/['\"\\]/g, '\\$&');
+}
+
+function buildArgExpression(param: ParamInfo): string {
+    const key = param.key ? escapeKey(param.key) : undefined;
+
+    switch (param.type) {
+        case 'param':
+            return key ? `c.params['${key}']` : 'c.params';
+
+        case 'query':
+            return key ? `c.query['${key}']` : 'c.query';
+
+        case 'body':
+            return key ? `c.body['${key}']` : 'c.body';
+
+        case 'header':
+            return key ? `c.req.headers.get('${key}')` : 'c.req.headers';
+
+        case 'req':
+            return 'c.req';
+
+        case 'ctx':
+            return 'c';
+
+        case 'locals':
+            return key ? `c.locals['${key}']` : 'c.locals';
+
+        default:
+            return 'undefined';
+    }
+}