@carno.js/core 1.1.1 → 1.1.2

package/src/container/Container.ts

@@ -1,168 +1,168 @@
-/**
- * Lightweight DI Container for Turbo.
- * 
- * Features:
- * - Constructor injection via reflect-metadata
- * - Singleton scope by default
- * - Request scope support
- * - Lazy instantiation
- */
-
-export type Token<T = any> = new (...args: any[]) => T;
-
-export enum Scope {
-    SINGLETON = 'singleton', // Always the same instance
-    REQUEST = 'request',     // New instance per request
-    INSTANCE = 'instance'    // New instance per dependency injection
-}
-
-export interface ProviderConfig<T = any> {
-    token: Token<T>;
-    useClass?: Token<T>;
-    useValue?: T;
-    scope?: Scope;
-}
-
-interface ProviderEntry {
-    config: ProviderConfig;
-    instance: any | null;
-}
-
-export class Container {
-    private configs = new Map<Token, ProviderConfig>();
-    private instances = new Map<Token, any>();
-    private resolving = new Set<Token>();
-
-    register<T>(config: ProviderConfig<T> | Token<T>): this {
-        const normalized = this.normalizeConfig(config);
-
-        this.configs.set(normalized.token, normalized);
-
-        if (normalized.useValue !== undefined) {
-            this.instances.set(normalized.token, normalized.useValue);
-        }
-
-        return this;
-    }
-
-    get<T>(token: Token<T>): T {
-        const cached = this.instances.get(token);
-
-        if (cached !== undefined) {
-            return cached;
-        }
-
-        const res = this.resolveInternal(token);
-        return res.instance;
-    }
-
-    has(token: Token): boolean {
-        return this.configs.has(token);
-    }
-
-    /**
-     * Resolves a token to return instance and its effective scope.
-     */
-    private resolveInternal<T>(token: Token<T>, requestLocals?: Map<Token, any>): { instance: T, scope: Scope } {
-        // 1. Check Request Cache
-        if (requestLocals?.has(token)) {
-            return { instance: requestLocals.get(token), scope: Scope.REQUEST };
-        }
-
-        // 2. Check Singleton Cache
-        const cached = this.instances.get(token);
-        if (cached !== undefined) {
-            return { instance: cached, scope: Scope.SINGLETON };
-        }
-
-        const config = this.configs.get(token);
-
-        if (!config) {
-            throw new Error(`Provider not found: ${token.name}`);
-        }
-
-        // 3. Create Instance with Scope Bubbling
-        const creation = this.createInstance(config, requestLocals);
-
-        // 4. Cache based on Effective Scope
-        if (creation.scope === Scope.SINGLETON) {
-            this.instances.set(token, creation.instance);
-        } else if (creation.scope === Scope.REQUEST && requestLocals) {
-            requestLocals.set(token, creation.instance);
-        }
-        // INSTANCE scope is never cached
-
-        return creation;
-    }
-
-    private createInstance(config: ProviderConfig, requestLocals?: Map<Token, any>): { instance: any, scope: Scope } {
-        const target = config.useClass ?? config.token;
-
-        if (this.resolving.has(target)) {
-            throw new Error(`Circular dependency detected: ${target.name}`);
-        }
-
-        this.resolving.add(target);
-
-        try {
-            const depsToken = this.getDependencies(target);
-
-            if (depsToken.length === 0) {
-                // No deps: Scope is as configured
-                return { instance: new target(), scope: config.scope || Scope.SINGLETON };
-            }
-
-            const args: any[] = [];
-            let effectiveScope = config.scope || Scope.SINGLETON;
-
-            for (const depToken of depsToken) {
-                const depResult = this.resolveInternal(depToken, requestLocals);
-                args.push(depResult.instance);
-
-                // Scope Bubbling Logic:
-                // If a dependency is REQUEST scoped, the parent MUST become REQUEST scoped (if it was Singleton)
-                // to avoid holding a stale reference to a request-bound instance.
-                if (depResult.scope === Scope.REQUEST && effectiveScope === Scope.SINGLETON) {
-                    effectiveScope = Scope.REQUEST;
-                }
-
-                // Note: INSTANCE scope dependencies do not force bubbling because they are transient and safe to hold (usually),
-                // unless semantic logic dictates otherwise. For now, strictly bubbling REQUEST scope.
-            }
-
-            return { instance: new target(...args), scope: effectiveScope };
-        } finally {
-            this.resolving.delete(target);
-        }
-    }
-
-    private getDependencies(target: Token): Token[] {
-        const types = Reflect.getMetadata('design:paramtypes', target) || [];
-        return types.filter((t: any) => t && typeof t === 'function' && !this.isPrimitive(t));
-    }
-
-    private isPrimitive(type: any): boolean {
-        return type === String || type === Number || type === Boolean || type === Object || type === Array || type === Symbol;
-    }
-
-    private normalizeConfig<T>(config: ProviderConfig<T> | Token<T>): ProviderConfig<T> {
-        if (typeof config === 'function') {
-            return {
-                token: config,
-                useClass: config,
-                scope: Scope.SINGLETON
-            };
-        }
-
-        return {
-            ...config,
-            useClass: config.useClass ?? config.token,
-            scope: config.scope ?? Scope.SINGLETON
-        };
-    }
-
-    clear(): void {
-        this.configs.clear();
-        this.instances.clear();
-    }
-}
+/**
+ * Lightweight DI Container for Turbo.
+ * 
+ * Features:
+ * - Constructor injection via reflect-metadata
+ * - Singleton scope by default
+ * - Request scope support
+ * - Lazy instantiation
+ */
+
+export type Token<T = any> = new (...args: any[]) => T;
+
+export enum Scope {
+    SINGLETON = 'singleton', // Always the same instance
+    REQUEST = 'request',     // New instance per request
+    INSTANCE = 'instance'    // New instance per dependency injection
+}
+
+export interface ProviderConfig<T = any> {
+    token: Token<T>;
+    useClass?: Token<T>;
+    useValue?: T;
+    scope?: Scope;
+}
+
+interface ProviderEntry {
+    config: ProviderConfig;
+    instance: any | null;
+}
+
+export class Container {
+    private configs = new Map<Token, ProviderConfig>();
+    private instances = new Map<Token, any>();
+    private resolving = new Set<Token>();
+
+    register<T>(config: ProviderConfig<T> | Token<T>): this {
+        const normalized = this.normalizeConfig(config);
+
+        this.configs.set(normalized.token, normalized);
+
+        if (normalized.useValue !== undefined) {
+            this.instances.set(normalized.token, normalized.useValue);
+        }
+
+        return this;
+    }
+
+    get<T>(token: Token<T>): T {
+        const cached = this.instances.get(token);
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const res = this.resolveInternal(token);
+        return res.instance;
+    }
+
+    has(token: Token): boolean {
+        return this.configs.has(token);
+    }
+
+    /**
+     * Resolves a token to return instance and its effective scope.
+     */
+    private resolveInternal<T>(token: Token<T>, requestLocals?: Map<Token, any>): { instance: T, scope: Scope } {
+        // 1. Check Request Cache
+        if (requestLocals?.has(token)) {
+            return { instance: requestLocals.get(token), scope: Scope.REQUEST };
+        }
+
+        // 2. Check Singleton Cache
+        const cached = this.instances.get(token);
+        if (cached !== undefined) {
+            return { instance: cached, scope: Scope.SINGLETON };
+        }
+
+        const config = this.configs.get(token);
+
+        if (!config) {
+            throw new Error(`Provider not found: ${token.name}`);
+        }
+
+        // 3. Create Instance with Scope Bubbling
+        const creation = this.createInstance(config, requestLocals);
+
+        // 4. Cache based on Effective Scope
+        if (creation.scope === Scope.SINGLETON) {
+            this.instances.set(token, creation.instance);
+        } else if (creation.scope === Scope.REQUEST && requestLocals) {
+            requestLocals.set(token, creation.instance);
+        }
+        // INSTANCE scope is never cached
+
+        return creation;
+    }
+
+    private createInstance(config: ProviderConfig, requestLocals?: Map<Token, any>): { instance: any, scope: Scope } {
+        const target = config.useClass ?? config.token;
+
+        if (this.resolving.has(target)) {
+            throw new Error(`Circular dependency detected: ${target.name}`);
+        }
+
+        this.resolving.add(target);
+
+        try {
+            const depsToken = this.getDependencies(target);
+
+            if (depsToken.length === 0) {
+                // No deps: Scope is as configured
+                return { instance: new target(), scope: config.scope || Scope.SINGLETON };
+            }
+
+            const args: any[] = [];
+            let effectiveScope = config.scope || Scope.SINGLETON;
+
+            for (const depToken of depsToken) {
+                const depResult = this.resolveInternal(depToken, requestLocals);
+                args.push(depResult.instance);
+
+                // Scope Bubbling Logic:
+                // If a dependency is REQUEST scoped, the parent MUST become REQUEST scoped (if it was Singleton)
+                // to avoid holding a stale reference to a request-bound instance.
+                if (depResult.scope === Scope.REQUEST && effectiveScope === Scope.SINGLETON) {
+                    effectiveScope = Scope.REQUEST;
+                }
+
+                // Note: INSTANCE scope dependencies do not force bubbling because they are transient and safe to hold (usually),
+                // unless semantic logic dictates otherwise. For now, strictly bubbling REQUEST scope.
+            }
+
+            return { instance: new target(...args), scope: effectiveScope };
+        } finally {
+            this.resolving.delete(target);
+        }
+    }
+
+    private getDependencies(target: Token): Token[] {
+        const types = Reflect.getMetadata('design:paramtypes', target) || [];
+        return types.filter((t: any) => t && typeof t === 'function' && !this.isPrimitive(t));
+    }
+
+    private isPrimitive(type: any): boolean {
+        return type === String || type === Number || type === Boolean || type === Object || type === Array || type === Symbol;
+    }
+
+    private normalizeConfig<T>(config: ProviderConfig<T> | Token<T>): ProviderConfig<T> {
+        if (typeof config === 'function') {
+            return {
+                token: config,
+                useClass: config,
+                scope: Scope.SINGLETON
+            };
+        }
+
+        return {
+            ...config,
+            useClass: config.useClass ?? config.token,
+            scope: config.scope ?? Scope.SINGLETON
+        };
+    }
+
+    clear(): void {
+        this.configs.clear();
+        this.instances.clear();
+    }
+}

package/src/context/Context.ts

@@ -1,130 +1,130 @@
-/**
- * Request Context for Turbo.
- * 
- * Lazy initialization for maximum performance:
- * - Query parsed only when accessed
- * - Body parsed only when needed
- * - Minimal allocations in hot path
- */
-
-import { parseQueryFromURL } from '../utils/parseQuery';
-
-const EMPTY_PARAMS: Record<string, string> = Object.freeze({}) as Record<string, string>;
-
-export class Context {
-    readonly req: Request;
-    params: Record<string, string>;
-    locals: Record<string, any> = {};
-
-    // Lazy fields - only allocated when accessed
-    private _query: Record<string, string> | null = null;
-    private _body: any;
-    private _bodyParsed = false;
-    private _url: URL | null = null;
-    private _status = 0;
-
-    constructor(req: Request, params: Record<string, string> = EMPTY_PARAMS) {
-        this.req = req;
-        this.params = params;
-    }
-
-    get status(): number {
-        return this._status || 200;
-    }
-
-    set status(value: number) {
-        this._status = value;
-    }
-
-    get url(): URL {
-        if (!this._url) {
-            this._url = new URL(this.req.url);
-        }
-
-        return this._url;
-    }
-
-    get query(): Record<string, string> {
-        if (!this._query) {
-            this._query = parseQueryFromURL(this.req.url);
-        }
-
-        return this._query;
-    }
-
-    get body(): any {
-        return this._body;
-    }
-
-    async parseBody(): Promise<any> {
-        if (this._bodyParsed) {
-            return this._body;
-        }
-
-        this._bodyParsed = true;
-        const contentType = this.req.headers.get('content-type') || '';
-
-        if (contentType.includes('application/json')) {
-            this._body = await this.req.json();
-        } else if (contentType.includes('form')) {
-            const formData = await this.req.formData();
-            this._body = Object.fromEntries(formData);
-        } else if (contentType.includes('text')) {
-            this._body = await this.req.text();
-        } else {
-            this._body = await this.req.arrayBuffer();
-        }
-
-        return this._body;
-    }
-
-    get method(): string {
-        return this.req.method;
-    }
-
-    get headers(): Headers {
-        return this.req.headers;
-    }
-
-    get path(): string {
-        return this.url.pathname;
-    }
-
-    json(data: any, status?: number): Response {
-        if (status) this.status = status;
-
-        return Response.json(data, { status: this.status });
-    }
-
-    text(data: string, status?: number): Response {
-        if (status) this.status = status;
-
-        return new Response(data, {
-            status: this.status,
-            headers: { 'Content-Type': 'text/plain' }
-        });
-    }
-
-    html(data: string, status?: number): Response {
-        if (status) this.status = status;
-
-        return new Response(data, {
-            status: this.status,
-            headers: { 'Content-Type': 'text/html' }
-        });
-    }
-
-    redirect(url: string, status: number = 302): Response {
-        return Response.redirect(url, status);
-    }
-
-    /**
-     * Creates a Context from a job (for queue processing).
-     */
-    static createFromJob(job: any): Context {
-        const fakeRequest = new Request('http://localhost/job');
-        const ctx = new Context(fakeRequest);
-        ctx.locals.job = job;
-        return ctx;
-    }
-}
+/**
+ * Request Context for Turbo.
+ * 
+ * Lazy initialization for maximum performance:
+ * - Query parsed only when accessed
+ * - Body parsed only when needed
+ * - Minimal allocations in hot path
+ */
+
+import { parseQueryFromURL } from '../utils/parseQuery';
+
+const EMPTY_PARAMS: Record<string, string> = Object.freeze({}) as Record<string, string>;
+
+export class Context {
+    readonly req: Request;
+    params: Record<string, string>;
+    locals: Record<string, any> = {};
+
+    // Lazy fields - only allocated when accessed
+    private _query: Record<string, string> | null = null;
+    private _body: any;
+    private _bodyParsed = false;
+    private _url: URL | null = null;
+    private _status = 0;
+
+    constructor(req: Request, params: Record<string, string> = EMPTY_PARAMS) {
+        this.req = req;
+        this.params = params;
+    }
+
+    get status(): number {
+        return this._status || 200;
+    }
+
+    set status(value: number) {
+        this._status = value;
+    }
+
+    get url(): URL {
+        if (!this._url) {
+            this._url = new URL(this.req.url);
+        }
+
+        return this._url;
+    }
+
+    get query(): Record<string, string> {
+        if (!this._query) {
+            this._query = parseQueryFromURL(this.req.url);
+        }
+
+        return this._query;
+    }
+
+    get body(): any {
+        return this._body;
+    }
+
+    async parseBody(): Promise<any> {
+        if (this._bodyParsed) {
+            return this._body;
+        }
+
+        this._bodyParsed = true;
+        const contentType = this.req.headers.get('content-type') || '';
+
+        if (contentType.includes('application/json')) {
+            this._body = await this.req.json();
+        } else if (contentType.includes('form')) {
+            const formData = await this.req.formData();
+            this._body = Object.fromEntries(formData);
+        } else if (contentType.includes('text')) {
+            this._body = await this.req.text();
+        } else {
+            this._body = await this.req.arrayBuffer();
+        }
+
+        return this._body;
+    }
+
+    get method(): string {
+        return this.req.method;
+    }
+
+    get headers(): Headers {
+        return this.req.headers;
+    }
+
+    get path(): string {
+        return this.url.pathname;
+    }
+
+    json(data: any, status?: number): Response {
+        if (status) this.status = status;
+
+        return Response.json(data, { status: this.status });
+    }
+
+    text(data: string, status?: number): Response {
+        if (status) this.status = status;
+
+        return new Response(data, {
+            status: this.status,
+            headers: { 'Content-Type': 'text/plain' }
+        });
+    }
+
+    html(data: string, status?: number): Response {
+        if (status) this.status = status;
+
+        return new Response(data, {
+            status: this.status,
+            headers: { 'Content-Type': 'text/html' }
+        });
+    }
+
+    redirect(url: string, status: number = 302): Response {
+        return Response.redirect(url, status);
+    }
+
+    /**
+     * Creates a Context from a job (for queue processing).
+     */
+    static createFromJob(job: any): Context {
+        const fakeRequest = new Request('http://localhost/job');
+        const ctx = new Context(fakeRequest);
+        ctx.locals.job = job;
+        return ctx;
+    }
+}