@hazeljs/core 0.2.0-beta.1

package/dist/container.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = exports.Scope = void 0;
+require("reflect-metadata");
+const logger_1 = __importDefault(require("./logger"));
+var Scope;
+(function (Scope) {
+    Scope["SINGLETON"] = "singleton";
+    Scope["TRANSIENT"] = "transient";
+    Scope["REQUEST"] = "request";
+})(Scope || (exports.Scope = Scope = {}));
+class Container {
+    // Note: resolutionStack is used per-resolve chain via parameter threading, not shared state
+    constructor() {
+        this.providers = new Map();
+        this.requestScopedProviders = new Map();
+        logger_1.default.info('Container initialized');
+    }
+    static getInstance() {
+        if (!Container.instance) {
+            Container.instance = new Container();
+        }
+        return Container.instance;
+    }
+    /**
+     * Create a new container instance (for testing)
+     */
+    static createTestInstance() {
+        return new Container();
+    }
+    /**
+     * Register a provider with the container
+     */
+    register(token, provider, scope = Scope.SINGLETON) {
+        const tokenName = this.getTokenName(token);
+        logger_1.default.info(`Registering provider: ${tokenName} with scope: ${scope}`);
+        if (this.isProvider(provider)) {
+            this.registerProvider(provider);
+        }
+        else {
+            this.providers.set(token, {
+                instance: provider,
+                scope,
+            });
+        }
+    }
+    /**
+     * Register a provider configuration
+     */
+    registerProvider(provider) {
+        const tokenName = this.getTokenName(provider.token);
+        logger_1.default.debug(`Registering provider configuration: ${tokenName}`);
+        const scope = provider.scope || Scope.SINGLETON;
+        const metadata = { scope };
+        if (provider.useValue !== undefined) {
+            metadata.instance = provider.useValue;
+        }
+        else if (provider.useFactory) {
+            metadata.factory = (requestId) => {
+                const deps = (provider.inject || []).map((dep) => this.resolve(dep, requestId));
+                return provider.useFactory(...deps);
+            };
+        }
+        else if (provider.useClass) {
+            metadata.factory = (requestId) => this.createInstance(provider.useClass, requestId);
+        }
+        this.providers.set(provider.token, metadata);
+    }
+    /**
+     * Resolve a dependency from the container
+     */
+    resolve(token, requestId, resolutionStack) {
+        if (!token) {
+            if (logger_1.default.isDebugEnabled()) {
+                logger_1.default.debug('No token provided for resolution');
+            }
+            return undefined;
+        }
+        if (logger_1.default.isDebugEnabled()) {
+            const tokenName = this.getTokenName(token);
+            logger_1.default.debug(`Resolving dependency: ${tokenName}`);
+        }
+        // Check if provider is registered
+        const metadata = this.providers.get(token);
+        if (metadata) {
+            return this.resolveFromMetadata(token, metadata, requestId, resolutionStack);
+        }
+        // If token is a class, try to auto-resolve
+        if (typeof token === 'function' && token.prototype) {
+            return this.autoResolve(token, requestId, resolutionStack);
+        }
+        if (logger_1.default.isDebugEnabled()) {
+            logger_1.default.warn(`No provider found for token: ${this.getTokenName(token)}`);
+        }
+        return undefined;
+    }
+    /**
+     * Resolve from provider metadata
+     */
+    resolveFromMetadata(token, metadata, requestId, resolutionStack) {
+        const tokenName = this.getTokenName(token);
+        // Use per-chain resolution stack to detect circular deps (thread-safe)
+        const stack = resolutionStack || new Set();
+        if (stack.has(token)) {
+            const chain = Array.from(stack).map(t => this.getTokenName(t));
+            chain.push(tokenName);
+            throw new Error(`Circular dependency detected: ${chain.join(' → ')}`);
+        }
+        stack.add(token);
+        try {
+            // Handle different scopes
+            switch (metadata.scope) {
+                case Scope.SINGLETON:
+                    if (metadata.instance !== undefined) {
+                        return metadata.instance;
+                    }
+                    if (metadata.isResolving) {
+                        // Another resolve is already creating this singleton — wait would deadlock in sync, so error
+                        throw new Error(`Singleton ${tokenName} is already being resolved (possible async race)`);
+                    }
+                    if (metadata.factory) {
+                        metadata.isResolving = true;
+                        try {
+                            const result = metadata.factory(requestId);
+                            metadata.instance = result;
+                            return metadata.instance;
+                        }
+                        finally {
+                            metadata.isResolving = false;
+                        }
+                    }
+                    break;
+                case Scope.TRANSIENT:
+                    if (metadata.factory) {
+                        return metadata.factory(requestId);
+                    }
+                    break;
+                case Scope.REQUEST:
+                    if (!requestId) {
+                        throw new Error(`Request scope requires requestId for: ${tokenName}`);
+                    }
+                    return this.resolveRequestScoped(token, metadata, requestId);
+            }
+            return undefined;
+        }
+        finally {
+            stack.delete(token);
+        }
+    }
+    /**
+     * Resolve request-scoped provider
+     */
+    resolveRequestScoped(token, metadata, requestId) {
+        let requestProviders = this.requestScopedProviders.get(requestId);
+        if (!requestProviders) {
+            requestProviders = new Map();
+            this.requestScopedProviders.set(requestId, requestProviders);
+        }
+        if (requestProviders.has(token)) {
+            return requestProviders.get(token);
+        }
+        if (metadata.factory) {
+            const instance = metadata.factory(requestId);
+            requestProviders.set(token, instance);
+            return instance;
+        }
+        return undefined;
+    }
+    /**
+     * Auto-resolve a class without explicit registration
+     */
+    autoResolve(token, requestId, resolutionStack) {
+        if (logger_1.default.isDebugEnabled()) {
+            logger_1.default.debug(`Auto-resolving: ${token.name}`);
+        }
+        // Check if already registered
+        if (this.providers.has(token)) {
+            return this.resolve(token, requestId, resolutionStack);
+        }
+        // Get scope from metadata
+        const scope = Reflect.getMetadata('hazel:scope', token) || Scope.SINGLETON;
+        // Create factory for the class
+        const factory = (reqId) => this.createInstance(token, reqId, resolutionStack);
+        this.providers.set(token, { scope, factory });
+        return this.resolve(token, requestId, resolutionStack);
+    }
+    /**
+     * Create instance of a class with dependency injection
+     */
+    createInstance(token, requestId, resolutionStack) {
+        // Get constructor parameters
+        const params = Reflect.getMetadata('design:paramtypes', token) || [];
+        if (logger_1.default.isDebugEnabled()) {
+            logger_1.default.debug(`Constructor parameters: ${params.map((p) => p?.name || 'undefined').join(', ')}`);
+        }
+        // Get injection tokens if specified
+        const injectionTokens = Reflect.getMetadata('hazel:inject', token) || [];
+        // Resolve dependencies
+        const dependencies = params.map((param, index) => {
+            const injectionToken = injectionTokens[index];
+            const tokenToResolve = injectionToken || param;
+            if (!tokenToResolve) {
+                if (logger_1.default.isDebugEnabled()) {
+                    logger_1.default.debug('Undefined parameter type found');
+                }
+                return undefined;
+            }
+            if (logger_1.default.isDebugEnabled()) {
+                logger_1.default.debug(`Resolving dependency for: ${this.getTokenName(tokenToResolve)}`);
+            }
+            return this.resolve(tokenToResolve, requestId, resolutionStack);
+        });
+        // Create instance with dependencies
+        const instance = new token(...dependencies);
+        if (logger_1.default.isDebugEnabled()) {
+            logger_1.default.info(`Created instance of: ${this.getTokenName(token)}`);
+        }
+        return instance;
+    }
+    /**
+     * Clear request-scoped providers for a specific request
+     */
+    clearRequestScope(requestId) {
+        if (logger_1.default.isDebugEnabled()) {
+            logger_1.default.debug(`Clearing request scope: ${requestId}`);
+        }
+        this.requestScopedProviders.delete(requestId);
+    }
+    /**
+     * Clear all providers
+     */
+    clear() {
+        logger_1.default.info('Clearing container');
+        this.providers.clear();
+        this.requestScopedProviders.clear();
+    }
+    /**
+     * Check if a token is registered
+     */
+    has(token) {
+        return this.providers.has(token);
+    }
+    /**
+     * Get all registered tokens
+     */
+    getTokens() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * Helper to get token name for logging
+     */
+    getTokenName(token) {
+        if (typeof token === 'string')
+            return token;
+        if (typeof token === 'symbol')
+            return token.toString();
+        if (typeof token === 'function')
+            return token.name;
+        return 'unknown';
+    }
+    /**
+     * Type guard to check if value is a Provider
+     */
+    isProvider(value) {
+        return typeof value === 'object' && value !== null && 'token' in value;
+    }
+}
+exports.Container = Container;

package/dist/decorators.d.ts

@@ -0,0 +1,92 @@
+import 'reflect-metadata';
+import { Type } from './types';
+import { PipeTransform, PipeMetadata } from './pipes/pipe';
+import { Interceptor, InterceptorMetadata } from './interceptors/interceptor';
+import { HazelApp } from './hazel-app';
+export interface ControllerMetadata {
+    path: string;
+    interceptors?: InterceptorMetadata[];
+}
+export interface RouteMetadata {
+    path: string;
+    method: string;
+    handler: string | symbol;
+    middlewares?: Type<unknown>[];
+    pipes?: PipeMetadata[];
+}
+export interface ControllerOptions {
+    path: string;
+    version?: string;
+}
+export interface RouteOptions {
+    path?: string;
+    middlewares?: Type<unknown>[];
+    pipes?: PipeMetadata[];
+    interceptors?: InterceptorMetadata[];
+}
+export interface ServiceOptions {
+    scope?: 'singleton' | 'transient' | 'request';
+}
+export interface InjectableOptions {
+    scope?: 'singleton' | 'transient' | 'request';
+}
+export interface RepositoryOptions {
+    model: string;
+}
+export interface OnModuleInit {
+    onModuleInit(): Promise<void>;
+}
+export interface OnModuleDestroy {
+    onModuleDestroy(): Promise<void>;
+}
+export interface ExecutionContext {
+    switchToHttp(): {
+        getRequest(): unknown;
+        getResponse(): unknown;
+    };
+}
+export interface CanActivate {
+    canActivate(context: ExecutionContext): Promise<boolean> | boolean;
+}
+export { HazelModule, Module } from './hazel-module';
+export declare function Controller(options: ControllerOptions | string): ClassDecorator;
+export declare function Injectable(options?: InjectableOptions): ClassDecorator;
+export declare function Get(options?: {
+    path?: string;
+} | string): MethodDecorator;
+export declare function Post(options?: {
+    path?: string;
+} | string): MethodDecorator;
+export declare function Put(options?: {
+    path?: string;
+} | string): MethodDecorator;
+export declare function Delete(options?: {
+    path?: string;
+} | string): MethodDecorator;
+export declare function Patch(options?: {
+    path?: string;
+} | string): MethodDecorator;
+export declare function Inject(token?: string | symbol | Type<unknown>): ParameterDecorator;
+export declare function Service(options?: ServiceOptions): ClassDecorator;
+export declare function Body(dtoType?: Type<unknown>): ParameterDecorator;
+export declare function Request(): ParameterDecorator;
+export declare function Param(paramName: string, pipe?: Type<PipeTransform>): ParameterDecorator;
+export declare function Query(paramName?: string, pipe?: Type<PipeTransform>): ParameterDecorator;
+export declare function UsePipes(...pipes: (Type<PipeTransform> | PipeMetadata)[]): ClassDecorator & MethodDecorator;
+export declare function UseInterceptors(...interceptors: (Type<Interceptor> | InterceptorMetadata)[]): ClassDecorator & MethodDecorator;
+export declare function UseGuards(...guards: Type<CanActivate>[]): ClassDecorator & MethodDecorator;
+export declare function AITask(options: {
+    name: string;
+    prompt: string;
+    provider: string;
+    model: string;
+    outputType: string;
+}): MethodDecorator;
+export declare function Req(): ParameterDecorator;
+export declare function Headers(headerName?: string): ParameterDecorator;
+export declare function HttpCode(statusCode: number): MethodDecorator;
+export declare function Header(name: string, value: string): MethodDecorator;
+export declare function Redirect(url: string, statusCode?: number): MethodDecorator;
+export declare function Res(): ParameterDecorator;
+export { HazelApp };
+//# sourceMappingURL=decorators.d.ts.map

package/dist/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"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"}