@riktajs/core 0.8.0 → 0.9.0

package/README.md

@@ -49,6 +49,84 @@ await app.listen();
 - 📦 Built-in Dependency Injection
 - ✅ Zod Validation Integration
 
+## Provider Scopes
+
+Rikta supports three provider scopes:
+
+```typescript
+// Singleton (default) - shared instance
+@Injectable()
+class ConfigService {}
+
+// Transient - new instance each time
+@Injectable({ scope: 'transient' })
+class RequestLogger {}
+
+// Request - one instance per HTTP request
+@Injectable({ scope: 'request' })
+class RequestContext {}
+```
+
+## Strict Discovery Mode
+
+Enable strict discovery to catch import errors early:
+
+```typescript
+const app = await Rikta.create({
+  strictDiscovery: process.env.NODE_ENV !== 'production',
+  onDiscoveryError: (file, error) => {
+    console.warn(`Failed to import: ${file}`);
+  },
+});
+```
+
+## EventBus
+
+The EventBus provides pub/sub for lifecycle events:
+
+```typescript
+import { Injectable, Autowired, EventBus } from '@riktajs/core';
+
+@Injectable()
+class MonitorService {
+  @Autowired()
+  private events!: EventBus;
+
+  onProviderInit() {
+    this.events.on('app:listen', ({ address }) => {
+      console.log(`Server at ${address}`);
+    });
+  }
+}
+```
+
+## Interceptors
+
+Interceptors allow you to bind extra logic before/after method execution:
+
+```typescript
+import { Injectable, Interceptor, ExecutionContext, CallHandler, UseInterceptors } from '@riktajs/core';
+
+@Injectable()
+class LoggingInterceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<unknown> {
+    const start = Date.now();
+    const result = await next.handle();
+    console.log(`Request took ${Date.now() - start}ms`);
+    return result;
+  }
+}
+
+@Controller('/api')
+@UseInterceptors(LoggingInterceptor)
+class ApiController {
+  @Get('/data')
+  getData() {
+    return { data: 'example' };
+  }
+}
+```
+
 ## License
 
 MIT

package/dist/core/application.js

@@ -27,7 +27,12 @@ class RiktaFactory {
             const patterns = Array.isArray(config.autowired) && config.autowired.length > 0
                 ? config.autowired
                 : ['./**'];
-            discoveredFiles = await (0, discovery_1.discoverModules)(patterns, callerDir);
+            discoveredFiles = await (0, discovery_1.discoverModules)({
+                patterns,
+                cwd: callerDir,
+                strict: config.strictDiscovery ?? false,
+                onImportError: config.onDiscoveryError,
+            });
         }
         const app = new RiktaApplicationImpl(config);
         await app.init(discoveredFiles);
@@ -169,7 +174,7 @@ class RiktaApplicationImpl {
         for (const { event, methodName } of metadata) {
             const method = instance[methodName];
             if (typeof method === 'function') {
-                this.events.on(event, method.bind(instance));
+                this.events.on(event, method.bind(instance), target.name);
             }
         }
     }
@@ -214,19 +219,21 @@ class RiktaApplicationImpl {
     async close(signal) {
         await this.events.emit('app:shutdown', { signal });
         const reversed = [...this.initializedProviders].reverse();
-        for (const { instance } of reversed) {
+        for (const { instance, name } of reversed) {
             if (this.hasHook(instance, 'onApplicationShutdown')) {
                 await instance.onApplicationShutdown(signal);
             }
             if (this.hasHook(instance, 'onProviderDestroy')) {
                 await instance.onProviderDestroy();
             }
+            this.events.removeByOwner(name);
         }
         await this.server.close();
         this.isListening = false;
         await this.events.emit('app:destroy', {
             uptime: Date.now() - this.startTime
         });
+        this.events.clear();
         if (!this.config.silent)
             console.log('\n👋 Application closed\n');
     }
@@ -239,4 +246,10 @@ class RiktaApplicationImpl {
     getContainer() {
         return this.container;
     }
+    getRouter() {
+        return this.router;
+    }
+    clearRouterCaches() {
+        this.router.clearAllCaches();
+    }
 }

package/dist/core/container/container.js

@@ -6,6 +6,7 @@ const constants_1 = require("../constants");
 const injection_token_1 = require("./injection-token");
 const registry_1 = require("../registry");
 const abstract_class_utils_1 = require("./abstract-class.utils");
+const request_scope_1 = require("./request-scope");
 class Container {
     static instance;
     singletons = new Map();
@@ -97,14 +98,32 @@ class Container {
         throw new Error(`Cannot resolve token: ${this.getTokenName(token)}`);
     }
     resolveAbstractClass(abstractClass, name) {
-        if (name) {
-            return registry_1.registry.resolveImplementation(abstractClass, name);
-        }
         const config = this.providers.get(abstractClass);
         if (config?.provider && 'useClass' in config.provider) {
             return config.provider.useClass;
         }
-        return registry_1.registry.resolveImplementation(abstractClass);
+        const implementations = registry_1.registry.getImplementations(abstractClass);
+        if (!implementations || implementations.length === 0) {
+            return undefined;
+        }
+        if (name) {
+            const named = implementations.find(i => i.name === name);
+            if (named) {
+                return named.implementation;
+            }
+            throw new Error(`No implementation named '${name}' found for abstract class ${abstractClass.name}. ` +
+                `Available names: ${implementations.filter(i => i.name).map(i => i.name).join(', ') || 'none'}`);
+        }
+        if (implementations.length === 1) {
+            return implementations[0].implementation;
+        }
+        const primary = implementations.find(i => i.isPrimary);
+        if (primary) {
+            return primary.implementation;
+        }
+        const implNames = implementations.map(i => i.implementation.name).join(', ');
+        throw new Error(`Multiple implementations found for abstract class ${abstractClass.name}: ${implNames}. ` +
+            `Use @Primary() to mark one as the default, or @Named() for qualified injection.`);
     }
     resolveProvider(provider, scope) {
         if (typeof provider === 'function') {
@@ -148,6 +167,16 @@ class Container {
         if (scope === 'singleton' && this.singletons.has(target)) {
             return this.singletons.get(target);
         }
+        if (scope === 'request') {
+            if (!request_scope_1.requestScopeStorage.isInRequestScope()) {
+                throw new Error(`Cannot resolve request-scoped provider '${target.name}' outside of a request context. ` +
+                    `Request-scoped providers can only be resolved during HTTP request handling.`);
+            }
+            const existingInstance = request_scope_1.requestScopeStorage.get(target);
+            if (existingInstance !== undefined) {
+                return existingInstance;
+            }
+        }
         this.resolutionStack.add(target);
         try {
             const injectMeta = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
@@ -188,6 +217,9 @@ class Container {
             if (scope === 'singleton') {
                 this.singletons.set(target, instance);
             }
+            else if (scope === 'request') {
+                request_scope_1.requestScopeStorage.set(target, instance);
+            }
             return instance;
         }
         finally {

package/dist/core/container/index.d.ts

@@ -2,3 +2,4 @@ export * from './container';
 export * from './injection-token';
 export * from './abstract-class.utils';
 export * from './implements.decorator';
+export * from './request-scope';

package/dist/core/container/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./container"), exports);
 __exportStar(require("./injection-token"), exports);
 __exportStar(require("./abstract-class.utils"), exports);
 __exportStar(require("./implements.decorator"), exports);
+__exportStar(require("./request-scope"), exports);

package/dist/core/container/request-scope.d.ts

@@ -0,0 +1,16 @@
+import { Token } from './injection-token';
+export declare class RequestScopeStorage {
+    private static instance;
+    private readonly asyncLocalStorage;
+    private constructor();
+    static getInstance(): RequestScopeStorage;
+    static reset(): void;
+    run<T>(fn: () => T): T;
+    runAsync<T>(fn: () => Promise<T>): Promise<T>;
+    isInRequestScope(): boolean;
+    get<T>(token: Token<T>): T | undefined;
+    set<T>(token: Token<T>, instance: T): void;
+    has(token: Token): boolean;
+    getStore(): Map<Token, unknown> | undefined;
+}
+export declare const requestScopeStorage: RequestScopeStorage;

package/dist/core/container/request-scope.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestScopeStorage = exports.RequestScopeStorage = void 0;
+const node_async_hooks_1 = require("node:async_hooks");
+class RequestScopeStorage {
+    static instance;
+    asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+    constructor() { }
+    static getInstance() {
+        if (!RequestScopeStorage.instance) {
+            RequestScopeStorage.instance = new RequestScopeStorage();
+        }
+        return RequestScopeStorage.instance;
+    }
+    static reset() {
+        RequestScopeStorage.instance = new RequestScopeStorage();
+    }
+    run(fn) {
+        const store = new Map();
+        return this.asyncLocalStorage.run(store, fn);
+    }
+    async runAsync(fn) {
+        const store = new Map();
+        return this.asyncLocalStorage.run(store, fn);
+    }
+    isInRequestScope() {
+        return this.asyncLocalStorage.getStore() !== undefined;
+    }
+    get(token) {
+        const store = this.asyncLocalStorage.getStore();
+        if (!store) {
+            return undefined;
+        }
+        return store.get(token);
+    }
+    set(token, instance) {
+        const store = this.asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error('Cannot set request-scoped instance outside of a request context. ' +
+                'Make sure RequestScopeStorage.run() or runAsync() is being used.');
+        }
+        store.set(token, instance);
+    }
+    has(token) {
+        const store = this.asyncLocalStorage.getStore();
+        return store?.has(token) ?? false;
+    }
+    getStore() {
+        return this.asyncLocalStorage.getStore();
+    }
+}
+exports.RequestScopeStorage = RequestScopeStorage;
+exports.requestScopeStorage = RequestScopeStorage.getInstance();

package/dist/core/discovery.d.ts

@@ -1,2 +1,3 @@
-export declare function discoverModules(patterns?: string[], cwd?: string): Promise<string[]>;
+import { DiscoveryOptions } from './exceptions/discovery.exception';
+export declare function discoverModules(optionsOrPatterns?: DiscoveryOptions | string[], cwd?: string): Promise<string[]>;
 export declare function getCallerDirectory(): string;

package/dist/core/discovery.js

@@ -41,6 +41,7 @@ exports.getCallerDirectory = getCallerDirectory;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const discovery_exception_1 = require("./exceptions/discovery.exception");
 const DEFAULT_IGNORE_PATTERNS = [
     '**/node_modules/**',
     '**/dist/**',
@@ -79,8 +80,14 @@ async function containsRiktaDecorators(filePath) {
         return false;
     }
 }
-async function discoverModules(patterns = ['./**/*.{ts,js}'], cwd) {
-    const baseDir = cwd ?? getEntryPointDirectory();
+async function discoverModules(optionsOrPatterns = ['./**/*.{ts,js}'], cwd) {
+    const options = Array.isArray(optionsOrPatterns)
+        ? { patterns: optionsOrPatterns, cwd }
+        : optionsOrPatterns;
+    const patterns = options.patterns ?? ['./**/*.{ts,js}'];
+    const strict = options.strict ?? false;
+    const onImportError = options.onImportError;
+    const baseDir = options.cwd ?? cwd ?? getEntryPointDirectory();
     const absoluteBaseDir = path_1.default.isAbsolute(baseDir)
         ? baseDir
         : path_1.default.resolve(process.cwd(), baseDir);
@@ -105,25 +112,30 @@ async function discoverModules(patterns = ['./**/*.{ts,js}'], cwd) {
         ignore: DEFAULT_IGNORE_PATTERNS,
         onlyFiles: true,
     });
-    const riktaFiles = [];
-    for (const file of files) {
-        if (await containsRiktaDecorators(file)) {
-            riktaFiles.push(file);
-        }
-    }
+    const decoratorChecks = await Promise.all(files.map(async (file) => ({ file, hasDecorators: await containsRiktaDecorators(file) })));
+    const riktaFiles = decoratorChecks
+        .filter(({ hasDecorators }) => hasDecorators)
+        .map(({ file }) => file);
     const importedFiles = [];
+    const failedImports = [];
     for (const file of riktaFiles) {
         try {
             const importPath = file.replace(/\.ts$/, '');
             await Promise.resolve(`${importPath}`).then(s => __importStar(require(s)));
             importedFiles.push(file);
         }
-        catch (error) {
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            onImportError?.(file, error);
             if (process.env.DEBUG) {
-                console.warn(`[Rikta] Failed to import ${file}:`, error);
+                console.warn(`[Rikta] Failed to import ${file}:`, error.message);
             }
+            failedImports.push({ filePath: file, error });
         }
     }
+    if (strict && failedImports.length > 0) {
+        throw new discovery_exception_1.DiscoveryException(failedImports);
+    }
     return importedFiles;
 }
 function getCallerDirectory() {

package/dist/core/exceptions/discovery.exception.d.ts

@@ -0,0 +1,18 @@
+export declare class DiscoveryException extends Error {
+    readonly filePath: string;
+    readonly originalError: Error;
+    readonly failedImports: DiscoveryFailure[];
+    constructor(filePath: string, originalError: Error);
+    constructor(failures: DiscoveryFailure[]);
+    getReport(): string;
+}
+export interface DiscoveryFailure {
+    filePath: string;
+    error: Error;
+}
+export interface DiscoveryOptions {
+    patterns?: string[];
+    cwd?: string;
+    strict?: boolean;
+    onImportError?: (filePath: string, error: Error) => void;
+}

package/dist/core/exceptions/discovery.exception.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryException = void 0;
+class DiscoveryException extends Error {
+    filePath;
+    originalError;
+    failedImports;
+    constructor(filePathOrFailures, originalError) {
+        if (typeof filePathOrFailures === 'string') {
+            const filePath = filePathOrFailures;
+            const error = originalError;
+            super(`[Rikta Discovery] Failed to import module: ${filePath}\n` +
+                `Reason: ${error.message}`);
+            this.filePath = filePath;
+            this.originalError = error;
+            this.failedImports = [{ filePath, error }];
+        }
+        else {
+            const failures = filePathOrFailures;
+            const fileList = failures.map(f => `  - ${f.filePath}: ${f.error.message}`).join('\n');
+            super(`[Rikta Discovery] Failed to import ${failures.length} module(s):\n${fileList}`);
+            this.filePath = failures[0]?.filePath ?? '';
+            this.originalError = failures[0]?.error ?? new Error('Unknown error');
+            this.failedImports = failures;
+        }
+        this.name = 'DiscoveryException';
+        Error.captureStackTrace(this, this.constructor);
+    }
+    getReport() {
+        const lines = ['Discovery Failures:', ''];
+        for (const { filePath, error } of this.failedImports) {
+            lines.push(`📁 ${filePath}`);
+            lines.push(`   Error: ${error.message}`);
+            if (error.stack) {
+                const stackLines = error.stack.split('\n').slice(1, 4);
+                lines.push(`   Stack: ${stackLines.join('\n          ')}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+exports.DiscoveryException = DiscoveryException;

package/dist/core/exceptions/index.d.ts

@@ -4,3 +4,4 @@ export { BadRequestException, UnauthorizedException, ForbiddenException, NotFoun
 export { ExceptionFilter, ExceptionContext, ErrorResponse, GlobalExceptionFilter, GlobalExceptionFilterOptions, createExceptionHandler, } from './exception-filter';
 export { Catch, CatchMetadata, CATCH_METADATA, getCatchMetadata } from './catch.decorator';
 export { ConfigProviderAlreadyRegisteredException, ConfigProviderNotFoundException, ConfigProviderInstantiationException, } from './config.exceptions';
+export { DiscoveryException, DiscoveryFailure, DiscoveryOptions, } from './discovery.exception';

package/dist/core/exceptions/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigProviderInstantiationException = exports.ConfigProviderNotFoundException = exports.ConfigProviderAlreadyRegisteredException = exports.getCatchMetadata = exports.CATCH_METADATA = exports.Catch = exports.createExceptionHandler = exports.GlobalExceptionFilter = exports.GatewayTimeoutException = exports.ServiceUnavailableException = exports.BadGatewayException = exports.NotImplementedException = exports.InternalServerErrorException = exports.TooManyRequestsException = exports.UnprocessableEntityException = exports.UnsupportedMediaTypeException = exports.PayloadTooLargeException = exports.GoneException = exports.ConflictException = exports.RequestTimeoutException = exports.NotAcceptableException = exports.MethodNotAllowedException = exports.NotFoundException = exports.ForbiddenException = exports.UnauthorizedException = exports.BadRequestException = exports.ValidationException = exports.HttpException = void 0;
+exports.DiscoveryException = exports.ConfigProviderInstantiationException = exports.ConfigProviderNotFoundException = exports.ConfigProviderAlreadyRegisteredException = exports.getCatchMetadata = exports.CATCH_METADATA = exports.Catch = exports.createExceptionHandler = exports.GlobalExceptionFilter = exports.GatewayTimeoutException = exports.ServiceUnavailableException = exports.BadGatewayException = exports.NotImplementedException = exports.InternalServerErrorException = exports.TooManyRequestsException = exports.UnprocessableEntityException = exports.UnsupportedMediaTypeException = exports.PayloadTooLargeException = exports.GoneException = exports.ConflictException = exports.RequestTimeoutException = exports.NotAcceptableException = exports.MethodNotAllowedException = exports.NotFoundException = exports.ForbiddenException = exports.UnauthorizedException = exports.BadRequestException = exports.ValidationException = exports.HttpException = void 0;
 var http_exception_1 = require("./http-exception");
 Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return http_exception_1.HttpException; } });
 var validation_exception_1 = require("./validation.exception");
@@ -35,3 +35,5 @@ var config_exceptions_1 = require("./config.exceptions");
 Object.defineProperty(exports, "ConfigProviderAlreadyRegisteredException", { enumerable: true, get: function () { return config_exceptions_1.ConfigProviderAlreadyRegisteredException; } });
 Object.defineProperty(exports, "ConfigProviderNotFoundException", { enumerable: true, get: function () { return config_exceptions_1.ConfigProviderNotFoundException; } });
 Object.defineProperty(exports, "ConfigProviderInstantiationException", { enumerable: true, get: function () { return config_exceptions_1.ConfigProviderInstantiationException; } });
+var discovery_exception_1 = require("./discovery.exception");
+Object.defineProperty(exports, "DiscoveryException", { enumerable: true, get: function () { return discovery_exception_1.DiscoveryException; } });

package/dist/core/guards/execution-context.d.ts

@@ -1,6 +1,11 @@
 import type { FastifyRequest, FastifyReply } from 'fastify';
 import type { Constructor } from '../types';
+export interface HttpArgumentsHost {
+    getRequest<T = FastifyRequest>(): T;
+    getResponse<T = FastifyReply>(): T;
+}
 export interface ExecutionContext {
+    switchToHttp(): HttpArgumentsHost;
     getRequest<T = FastifyRequest>(): T;
     getReply<T = FastifyReply>(): T;
     getClass(): Constructor;
@@ -12,7 +17,9 @@ export declare class ExecutionContextImpl implements ExecutionContext {
     private readonly reply;
     private readonly controllerClass;
     private readonly handlerName;
+    private readonly httpHost;
     constructor(request: FastifyRequest, reply: FastifyReply, controllerClass: Constructor, handlerName: string | symbol);
+    switchToHttp(): HttpArgumentsHost;
     getRequest<T = FastifyRequest>(): T;
     getReply<T = FastifyReply>(): T;
     getClass(): Constructor;

package/dist/core/guards/execution-context.js

@@ -6,11 +6,19 @@ class ExecutionContextImpl {
     reply;
     controllerClass;
     handlerName;
+    httpHost;
     constructor(request, reply, controllerClass, handlerName) {
         this.request = request;
         this.reply = reply;
         this.controllerClass = controllerClass;
         this.handlerName = handlerName;
+        this.httpHost = {
+            getRequest: () => this.request,
+            getResponse: () => this.reply,
+        };
+    }
+    switchToHttp() {
+        return this.httpHost;
     }
     getRequest() {
         return this.request;

package/dist/core/index.d.ts

@@ -10,8 +10,10 @@ export * from './decorators';
 export * from './exceptions';
 export * from './guards';
 export * from './middleware';
+export * from './interceptors';
 export * from './config';
 export * from './metadata';
+export * from './profiler';
 export { z } from 'zod';
 export type { ZodType, ZodSchema, ZodError, ZodIssue, infer as ZodInfer } from 'zod';
 export type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';

package/dist/core/index.js

@@ -27,7 +27,9 @@ __exportStar(require("./decorators"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./guards"), exports);
 __exportStar(require("./middleware"), exports);
+__exportStar(require("./interceptors"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./metadata"), exports);
+__exportStar(require("./profiler"), exports);
 var zod_1 = require("zod");
 Object.defineProperty(exports, "z", { enumerable: true, get: function () { return zod_1.z; } });

package/dist/core/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export { Interceptor, CallHandler } from './interceptor.interface';
+export { UseInterceptors, getInterceptorsMetadata, InterceptorClass } from './use-interceptors.decorator';

package/dist/core/interceptors/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInterceptorsMetadata = exports.UseInterceptors = void 0;
+var use_interceptors_decorator_1 = require("./use-interceptors.decorator");
+Object.defineProperty(exports, "UseInterceptors", { enumerable: true, get: function () { return use_interceptors_decorator_1.UseInterceptors; } });
+Object.defineProperty(exports, "getInterceptorsMetadata", { enumerable: true, get: function () { return use_interceptors_decorator_1.getInterceptorsMetadata; } });

package/dist/core/interceptors/interceptor.interface.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionContext } from '../guards/execution-context';
+export interface Interceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}
+export interface CallHandler {
+    handle(): Promise<unknown>;
+}

package/dist/core/interceptors/interceptor.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interceptors/use-interceptors.decorator.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { Constructor } from '../types';
+import type { Interceptor } from './interceptor.interface';
+export type InterceptorClass = Constructor<Interceptor>;
+export declare function UseInterceptors(...interceptors: InterceptorClass[]): ClassDecorator & MethodDecorator;
+export declare function getInterceptorsMetadata(controllerClass: Constructor, methodName: string | symbol): InterceptorClass[];

package/dist/core/interceptors/use-interceptors.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseInterceptors = UseInterceptors;
+exports.getInterceptorsMetadata = getInterceptorsMetadata;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function UseInterceptors(...interceptors) {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey && descriptor) {
+            const existingInterceptors = Reflect.getMetadata(constants_1.INTERCEPTORS_METADATA, target.constructor, propertyKey) ?? [];
+            Reflect.defineMetadata(constants_1.INTERCEPTORS_METADATA, [...existingInterceptors, ...interceptors], target.constructor, propertyKey);
+        }
+        else {
+            const existingInterceptors = Reflect.getMetadata(constants_1.INTERCEPTORS_METADATA, target) ?? [];
+            Reflect.defineMetadata(constants_1.INTERCEPTORS_METADATA, [...existingInterceptors, ...interceptors], target);
+        }
+    };
+}
+function getInterceptorsMetadata(controllerClass, methodName) {
+    const controllerInterceptors = Reflect.getMetadata(constants_1.INTERCEPTORS_METADATA, controllerClass) ?? [];
+    const methodInterceptors = Reflect.getMetadata(constants_1.INTERCEPTORS_METADATA, controllerClass, methodName) ?? [];
+    return [...controllerInterceptors, ...methodInterceptors];
+}

package/dist/core/lifecycle/event-bus.d.ts

@@ -37,16 +37,21 @@ type Listener<E extends LifecycleEvent> = (payload: EventPayload[E]) => void | P
 export declare class EventBus {
     private listeners;
     private onceListeners;
-    on<E extends LifecycleEvent>(event: E, listener: Listener<E>): () => void;
-    on<T = unknown>(event: string, listener: (payload: T) => void | Promise<void>): () => void;
-    once<E extends LifecycleEvent>(event: E, listener: Listener<E>): void;
-    once<T = unknown>(event: string, listener: (payload: T) => void | Promise<void>): void;
+    private ownerUnsubscribers;
+    on<E extends LifecycleEvent>(event: E, listener: Listener<E>, owner?: string): () => void;
+    on<T = unknown>(event: string, listener: (payload: T) => void | Promise<void>, owner?: string): () => void;
+    once<E extends LifecycleEvent>(event: E, listener: Listener<E>, owner?: string): void;
+    once<T = unknown>(event: string, listener: (payload: T) => void | Promise<void>, owner?: string): void;
     emit<E extends LifecycleEvent>(event: E, payload: EventPayload[E]): Promise<void>;
     emit<T = unknown>(event: string, payload: T): Promise<void>;
     waitFor<E extends LifecycleEvent>(event: E): Promise<EventPayload[E]>;
     waitFor<T = unknown>(event: string): Promise<T>;
     off(event: string): void;
+    removeByOwner(owner: string): void;
     clear(): void;
     listenerCount(event: string): number;
+    totalListenerCount(): number;
+    listenerCountByOwner(owner: string): number;
+    getOwners(): string[];
 }
 export {};

package/dist/core/lifecycle/event-bus.js

@@ -11,29 +11,53 @@ const injectable_decorator_1 = require("../decorators/injectable.decorator");
 let EventBus = class EventBus {
     listeners = new Map();
     onceListeners = new Map();
-    on(event, listener) {
+    ownerUnsubscribers = new Map();
+    on(event, listener, owner) {
         if (!this.listeners.has(event)) {
             this.listeners.set(event, new Set());
         }
-        this.listeners.get(event).add(listener);
-        return () => this.listeners.get(event)?.delete(listener);
+        const tracked = { listener, owner };
+        this.listeners.get(event).add(tracked);
+        const unsubscribe = () => {
+            this.listeners.get(event)?.delete(tracked);
+            if (owner) {
+                this.ownerUnsubscribers.get(owner)?.delete(unsubscribe);
+            }
+        };
+        if (owner) {
+            if (!this.ownerUnsubscribers.has(owner)) {
+                this.ownerUnsubscribers.set(owner, new Set());
+            }
+            this.ownerUnsubscribers.get(owner).add(unsubscribe);
+        }
+        return unsubscribe;
     }
-    once(event, listener) {
+    once(event, listener, owner) {
         if (!this.onceListeners.has(event)) {
             this.onceListeners.set(event, new Set());
         }
-        this.onceListeners.get(event).add(listener);
+        const tracked = { listener, owner };
+        this.onceListeners.get(event).add(tracked);
+        if (owner) {
+            if (!this.ownerUnsubscribers.has(owner)) {
+                this.ownerUnsubscribers.set(owner, new Set());
+            }
+            const unsubscribe = () => {
+                this.onceListeners.get(event)?.delete(tracked);
+            };
+            this.ownerUnsubscribers.get(owner).add(unsubscribe);
+        }
     }
     async emit(event, payload) {
         const listeners = this.listeners.get(event);
         if (listeners) {
-            for (const listener of listeners) {
+            for (const { listener } of listeners) {
                 await listener(payload);
             }
         }
         const onceListeners = this.onceListeners.get(event);
         if (onceListeners) {
-            for (const listener of onceListeners) {
+            for (const { listener } of onceListeners) {
                 await listener(payload);
             }
             this.onceListeners.delete(event);
@@ -46,14 +70,40 @@ let EventBus = class EventBus {
         this.listeners.delete(event);
         this.onceListeners.delete(event);
     }
+    removeByOwner(owner) {
+        const unsubscribers = this.ownerUnsubscribers.get(owner);
+        if (unsubscribers) {
+            for (const unsubscribe of unsubscribers) {
+                unsubscribe();
+            }
+            this.ownerUnsubscribers.delete(owner);
+        }
+    }
     clear() {
         this.listeners.clear();
         this.onceListeners.clear();
+        this.ownerUnsubscribers.clear();
     }
     listenerCount(event) {
         return (this.listeners.get(event)?.size ?? 0) +
             (this.onceListeners.get(event)?.size ?? 0);
     }
+    totalListenerCount() {
+        let count = 0;
+        for (const listeners of this.listeners.values()) {
+            count += listeners.size;
+        }
+        for (const listeners of this.onceListeners.values()) {
+            count += listeners.size;
+        }
+        return count;
+    }
+    listenerCountByOwner(owner) {
+        return this.ownerUnsubscribers.get(owner)?.size ?? 0;
+    }
+    getOwners() {
+        return [...this.ownerUnsubscribers.keys()];
+    }
 };
 exports.EventBus = EventBus;
 exports.EventBus = EventBus = __decorate([

package/dist/core/profiler/index.d.ts

@@ -0,0 +1,2 @@
+export { PerformanceProfiler, profiler, setGlobalProfiler, getGlobalProfiler } from './performance-profiler';
+export type { PerformanceMetric, RouteMetric, BootstrapMetrics } from './performance-profiler';

package/dist/core/profiler/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalProfiler = exports.setGlobalProfiler = exports.profiler = exports.PerformanceProfiler = void 0;
+var performance_profiler_1 = require("./performance-profiler");
+Object.defineProperty(exports, "PerformanceProfiler", { enumerable: true, get: function () { return performance_profiler_1.PerformanceProfiler; } });
+Object.defineProperty(exports, "profiler", { enumerable: true, get: function () { return performance_profiler_1.profiler; } });
+Object.defineProperty(exports, "setGlobalProfiler", { enumerable: true, get: function () { return performance_profiler_1.setGlobalProfiler; } });
+Object.defineProperty(exports, "getGlobalProfiler", { enumerable: true, get: function () { return performance_profiler_1.getGlobalProfiler; } });

package/dist/core/profiler/performance-profiler.d.ts

@@ -0,0 +1,42 @@
+import { EventBus } from '../lifecycle/event-bus';
+export interface PerformanceMetric {
+    name: string;
+    duration: number;
+    startTime: number;
+    metadata?: Record<string, unknown>;
+}
+export interface RouteMetric extends PerformanceMetric {
+    method: string;
+    path: string;
+    statusCode: number;
+}
+export interface BootstrapMetrics {
+    total: number;
+    discovery: number;
+    containerInit: number;
+    routeRegistration: number;
+    lifecycleHooks: number;
+}
+export declare class PerformanceProfiler {
+    private enabled;
+    private eventBus?;
+    private listeners;
+    private bootstrapMetrics;
+    constructor(options?: {
+        enabled?: boolean;
+        eventBus?: EventBus;
+    });
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    startTimer(name: string): (metadata?: Record<string, unknown>) => PerformanceMetric | null;
+    measure<T>(name: string, fn: () => T | Promise<T>): Promise<T>;
+    recordRouteMetric(metric: RouteMetric): void;
+    recordBootstrapPhase(phase: keyof BootstrapMetrics, duration: number): void;
+    getBootstrapMetrics(): Partial<BootstrapMetrics>;
+    onMetric(listener: (metric: PerformanceMetric) => void): () => void;
+    private emitMetric;
+    createConsoleTimer(prefix?: string): (name: string) => (metadata?: Record<string, unknown>) => void;
+}
+export declare let profiler: PerformanceProfiler;
+export declare function setGlobalProfiler(newProfiler: PerformanceProfiler): void;
+export declare function getGlobalProfiler(): PerformanceProfiler;

package/dist/core/profiler/performance-profiler.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profiler = exports.PerformanceProfiler = void 0;
+exports.setGlobalProfiler = setGlobalProfiler;
+exports.getGlobalProfiler = getGlobalProfiler;
+class PerformanceProfiler {
+    enabled = true;
+    eventBus;
+    listeners = [];
+    bootstrapMetrics = {};
+    constructor(options) {
+        this.enabled = options?.enabled ?? true;
+        this.eventBus = options?.eventBus;
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    startTimer(name) {
+        if (!this.enabled) {
+            return () => null;
+        }
+        const startTime = performance.now();
+        const startTimestamp = Date.now();
+        return (metadata) => {
+            const duration = performance.now() - startTime;
+            const metric = {
+                name,
+                duration,
+                startTime: startTimestamp,
+                metadata,
+            };
+            this.emitMetric(metric);
+            return metric;
+        };
+    }
+    async measure(name, fn) {
+        const end = this.startTimer(name);
+        try {
+            const result = await fn();
+            end();
+            return result;
+        }
+        catch (error) {
+            end({ error: true });
+            throw error;
+        }
+    }
+    recordRouteMetric(metric) {
+        if (!this.enabled)
+            return;
+        this.emitMetric(metric);
+        this.eventBus?.emit('profiler:route', metric);
+    }
+    recordBootstrapPhase(phase, duration) {
+        this.bootstrapMetrics[phase] = duration;
+    }
+    getBootstrapMetrics() {
+        return { ...this.bootstrapMetrics };
+    }
+    onMetric(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index !== -1) {
+                this.listeners.splice(index, 1);
+            }
+        };
+    }
+    emitMetric(metric) {
+        for (const listener of this.listeners) {
+            try {
+                listener(metric);
+            }
+            catch {
+            }
+        }
+        this.eventBus?.emit('profiler:metric', metric);
+    }
+    createConsoleTimer(prefix = '[Rikta]') {
+        return (name) => {
+            const end = this.startTimer(name);
+            return (metadata) => {
+                const metric = end(metadata);
+                if (metric) {
+                    console.log(`${prefix} ${metric.name}: ${metric.duration.toFixed(2)}ms`);
+                }
+            };
+        };
+    }
+}
+exports.PerformanceProfiler = PerformanceProfiler;
+exports.profiler = new PerformanceProfiler();
+function setGlobalProfiler(newProfiler) {
+    exports.profiler = newProfiler;
+}
+function getGlobalProfiler() {
+    return exports.profiler;
+}

package/dist/core/registry.d.ts

@@ -34,8 +34,6 @@ declare class Registry {
     setImplementationName(abstractClass: Constructor, implementation: Constructor, name: string): void;
     setPrimaryImplementation(abstractClass: Constructor, implementation: Constructor): void;
     getImplementations(abstractClass: Constructor): AbstractImplementation[];
-    resolveImplementation(abstractClass: Constructor, name?: string): Constructor | undefined;
-    getNamedImplementation(abstractClass: Constructor, name: string): Constructor | undefined;
     hasImplementation(abstractClass: Constructor): boolean;
     clearAbstractImplementations(): void;
 }

package/dist/core/registry.js

@@ -100,38 +100,6 @@ class Registry {
     getImplementations(abstractClass) {
         return this.abstractImplementations.get(abstractClass) ?? [];
     }
-    resolveImplementation(abstractClass, name) {
-        const implementations = this.abstractImplementations.get(abstractClass);
-        if (!implementations || implementations.length === 0) {
-            return undefined;
-        }
-        if (name) {
-            const named = implementations.find(i => i.name === name);
-            if (named) {
-                return named.implementation;
-            }
-            throw new Error(`No implementation named '${name}' found for abstract class ${abstractClass.name}. ` +
-                `Available names: ${implementations.filter(i => i.name).map(i => i.name).join(', ') || 'none'}`);
-        }
-        if (implementations.length === 1) {
-            return implementations[0].implementation;
-        }
-        const primary = implementations.find(i => i.isPrimary);
-        if (primary) {
-            return primary.implementation;
-        }
-        const implNames = implementations.map(i => i.implementation.name).join(', ');
-        throw new Error(`Multiple implementations found for abstract class ${abstractClass.name}: ${implNames}. ` +
-            `Use @Primary() to mark one as the default, or @Named() for qualified injection.`);
-    }
-    getNamedImplementation(abstractClass, name) {
-        const implementations = this.abstractImplementations.get(abstractClass);
-        if (!implementations) {
-            return undefined;
-        }
-        const named = implementations.find(i => i.name === name);
-        return named?.implementation;
-    }
     hasImplementation(abstractClass) {
         const implementations = this.abstractImplementations.get(abstractClass);
         return !!implementations && implementations.length > 0;

package/dist/core/router/router.d.ts

@@ -8,7 +8,15 @@ export declare class Router {
     private readonly globalPrefix;
     private readonly guardCache;
     private readonly middlewareCache;
+    private readonly interceptorCache;
     constructor(server: FastifyInstance, container: Container, globalPrefix?: string);
+    clearGuardCache(): void;
+    clearMiddlewareCache(): void;
+    clearInterceptorCache(): void;
+    clearAllCaches(): void;
+    getGuardCacheSize(): number;
+    getMiddlewareCacheSize(): number;
+    getInterceptorCacheSize(): number;
     registerController(controllerClass: Constructor, silent?: boolean): void;
     private registerRoute;
     private compileParamResolvers;
@@ -18,5 +26,7 @@ export declare class Router {
     private executeGuardsOptimized;
     private resolveMiddlewareInstances;
     private executeMiddlewareChain;
+    private resolveInterceptorInstances;
+    private executeInterceptorChain;
     private buildPath;
 }

package/dist/core/router/router.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Router = void 0;
 require("reflect-metadata");
+const request_scope_1 = require("../container/request-scope");
 const constants_1 = require("../constants");
 const create_param_decorator_1 = require("../decorators/create-param-decorator");
 const validation_exception_1 = require("../exceptions/validation.exception");
@@ -9,17 +10,42 @@ const exceptions_1 = require("../exceptions/exceptions");
 const execution_context_1 = require("../guards/execution-context");
 const use_guards_decorator_1 = require("../guards/use-guards.decorator");
 const use_middleware_decorator_1 = require("../middleware/use-middleware.decorator");
+const use_interceptors_decorator_1 = require("../interceptors/use-interceptors.decorator");
 class Router {
     server;
     container;
     globalPrefix;
     guardCache = new Map();
     middlewareCache = new Map();
+    interceptorCache = new Map();
     constructor(server, container, globalPrefix = '') {
         this.server = server;
         this.container = container;
         this.globalPrefix = globalPrefix;
     }
+    clearGuardCache() {
+        this.guardCache.clear();
+    }
+    clearMiddlewareCache() {
+        this.middlewareCache.clear();
+    }
+    clearInterceptorCache() {
+        this.interceptorCache.clear();
+    }
+    clearAllCaches() {
+        this.guardCache.clear();
+        this.middlewareCache.clear();
+        this.interceptorCache.clear();
+    }
+    getGuardCacheSize() {
+        return this.guardCache.size;
+    }
+    getMiddlewareCacheSize() {
+        return this.middlewareCache.size;
+    }
+    getInterceptorCacheSize() {
+        return this.interceptorCache.size;
+    }
     registerController(controllerClass, silent = false) {
         const controllerMeta = Reflect.getMetadata(constants_1.CONTROLLER_METADATA, controllerClass);
         if (!controllerMeta) {
@@ -43,6 +69,7 @@ class Router {
         const statusCode = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, controllerClass, route.handlerName);
         const guards = (0, use_guards_decorator_1.getGuardsMetadata)(controllerClass, route.handlerName);
         const middleware = (0, use_middleware_decorator_1.getMiddlewareMetadata)(controllerClass, route.handlerName);
+        const interceptors = (0, use_interceptors_decorator_1.getInterceptorsMetadata)(controllerClass, route.handlerName);
         const compiledResolvers = this.compileParamResolvers(paramsMeta);
         const hasBuiltinParams = compiledResolvers.length > 0;
         const hasCustomParams = customParamsMeta.length > 0;
@@ -56,11 +83,13 @@ class Router {
         const hasGuards = guardInstances.length > 0;
         const middlewareInstances = this.resolveMiddlewareInstances(middleware);
         const hasMiddleware = middlewareInstances.length > 0;
-        const needsContext = hasGuards || hasCustomParams;
+        const interceptorInstances = this.resolveInterceptorInstances(interceptors);
+        const hasInterceptors = interceptorInstances.length > 0;
+        const needsContext = hasGuards || hasCustomParams || hasInterceptors;
         const createContext = needsContext
             ? (req, rep) => new execution_context_1.ExecutionContextImpl(req, rep, controllerClass, route.handlerName)
             : null;
-        const routeHandler = async (request, reply) => {
+        const executeHandler = async (request, reply) => {
             const executionContext = createContext ? createContext(request, reply) : null;
             if (hasGuards && executionContext) {
                 await this.executeGuardsOptimized(guardInstances, executionContext);
@@ -68,17 +97,30 @@ class Router {
             if (hasMiddleware) {
                 await this.executeMiddlewareChain(middlewareInstances, request, reply);
             }
-            let args;
-            if (hasParams) {
-                args = await this.resolveAllParams(compiledResolvers, customParamsMeta, maxParamIndex, request, reply, executionContext);
+            const coreHandler = async () => {
+                let args;
+                if (hasParams) {
+                    args = await this.resolveAllParams(compiledResolvers, customParamsMeta, maxParamIndex, request, reply, executionContext);
+                }
+                const result = args
+                    ? await handler.apply(controllerInstance, args)
+                    : await handler.call(controllerInstance);
+                return result;
+            };
+            let result;
+            if (hasInterceptors && executionContext) {
+                result = await this.executeInterceptorChain(interceptorInstances, executionContext, coreHandler);
+            }
+            else {
+                result = await coreHandler();
             }
-            const result = args
-                ? await handler.apply(controllerInstance, args)
-                : await handler.call(controllerInstance);
             if (statusCode)
                 reply.status(statusCode);
             return result;
         };
+        const routeHandler = async (request, reply) => {
+            return request_scope_1.requestScopeStorage.runAsync(() => executeHandler(request, reply));
+        };
         const method = route.method.toLowerCase();
         this.server[method](fullPath, routeHandler);
         if (!silent)
@@ -217,6 +259,41 @@ class Router {
         };
         await next();
     }
+    resolveInterceptorInstances(interceptors) {
+        return interceptors.map(InterceptorClass => {
+            let instance = this.interceptorCache.get(InterceptorClass);
+            if (instance)
+                return instance;
+            try {
+                instance = this.container.resolve(InterceptorClass);
+            }
+            catch (error) {
+                throw new Error(`Failed to resolve interceptor ${InterceptorClass.name}. ` +
+                    `Make sure it is decorated with @Injectable(). ` +
+                    `Original error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (typeof instance.intercept !== 'function') {
+                throw new Error(`${InterceptorClass.name} does not implement Interceptor interface. ` +
+                    `The interceptor must have an intercept(context, next) method.`);
+            }
+            this.interceptorCache.set(InterceptorClass, instance);
+            return instance;
+        });
+    }
+    async executeInterceptorChain(interceptorInstances, context, coreHandler) {
+        let handler = coreHandler;
+        for (let i = interceptorInstances.length - 1; i >= 0; i--) {
+            const interceptor = interceptorInstances[i];
+            const nextHandler = handler;
+            handler = () => {
+                const callHandler = {
+                    handle: () => nextHandler()
+                };
+                return interceptor.intercept(context, callHandler);
+            };
+        }
+        return handler();
+    }
     buildPath(controllerPrefix, routePath) {
         const parts = [this.globalPrefix, controllerPrefix, routePath]
             .filter(Boolean)

package/dist/core/types.d.ts

@@ -37,6 +37,8 @@ export interface RiktaConfig {
     silent?: boolean;
     prefix?: string;
     autowired?: string[] | false;
+    strictDiscovery?: boolean;
+    onDiscoveryError?: (filePath: string, error: Error) => void;
     controllers?: Constructor[];
     providers?: Constructor[];
     exceptionFilter?: ExceptionFilterConfig;
@@ -46,13 +48,15 @@ export type MiddlewareFunction = (request: FastifyRequest, reply: FastifyReply,
 export interface Guard {
     canActivate(context: RouteContext): boolean | Promise<boolean>;
 }
-export interface Interceptor {
-    intercept(context: RouteContext, next: () => Promise<unknown>): Promise<unknown>;
-}
+import type { Router } from './router/router';
+import type { EventBus } from './lifecycle/event-bus';
 export interface RiktaApplication {
     readonly server: FastifyInstance;
     listen(): Promise<string>;
     close(): Promise<void>;
     getUrl(): string;
     getContainer(): Container;
+    getRouter(): Router;
+    getEventBus(): EventBus;
+    clearRouterCaches(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riktajs/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "A fast and modern TypeScript backend framework with zero-config autowiring, powered by Fastify",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",