@riktajs/core 0.7.0 → 0.9.0

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

@@ -3,12 +3,18 @@ interface ConfigProviderRegistration {
     token: string;
     providerClass: Constructor;
 }
+interface AbstractImplementation {
+    implementation: Constructor;
+    isPrimary: boolean;
+    name?: string;
+}
 declare class Registry {
     private static instance;
     private controllers;
     private providers;
     private customProviders;
     private configProviderMap;
+    private abstractImplementations;
     private constructor();
     static getInstance(): Registry;
     static reset(): void;
@@ -24,6 +30,12 @@ declare class Registry {
     registerConfigProvider(token: string, providerClass: Constructor): void;
     getConfigProviderRegistrations(): ConfigProviderRegistration[];
     clearConfigProviders(): void;
+    registerAbstractImplementation(abstractClass: Constructor, implementation: Constructor, name?: string): void;
+    setImplementationName(abstractClass: Constructor, implementation: Constructor, name: string): void;
+    setPrimaryImplementation(abstractClass: Constructor, implementation: Constructor): void;
+    getImplementations(abstractClass: Constructor): AbstractImplementation[];
+    hasImplementation(abstractClass: Constructor): boolean;
+    clearAbstractImplementations(): void;
 }
 export declare const registry: Registry;
 export { Registry };

package/dist/core/registry.js

@@ -8,6 +8,7 @@ class Registry {
     providers = new Set();
     customProviders = new Set();
     configProviderMap = new Map();
+    abstractImplementations = new Map();
     constructor() { }
     static getInstance() {
         if (!Registry.instance) {
@@ -62,6 +63,50 @@ class Registry {
     clearConfigProviders() {
         this.configProviderMap.clear();
     }
+    registerAbstractImplementation(abstractClass, implementation, name) {
+        const implementations = this.abstractImplementations.get(abstractClass) ?? [];
+        const existing = implementations.find(i => i.implementation === implementation);
+        if (!existing) {
+            implementations.push({
+                implementation,
+                isPrimary: false,
+                name,
+            });
+            this.abstractImplementations.set(abstractClass, implementations);
+        }
+        else if (name && !existing.name) {
+            existing.name = name;
+        }
+    }
+    setImplementationName(abstractClass, implementation, name) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        if (!implementations) {
+            return;
+        }
+        const impl = implementations.find(i => i.implementation === implementation);
+        if (impl) {
+            impl.name = name;
+        }
+    }
+    setPrimaryImplementation(abstractClass, implementation) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        if (!implementations) {
+            return;
+        }
+        for (const impl of implementations) {
+            impl.isPrimary = impl.implementation === implementation;
+        }
+    }
+    getImplementations(abstractClass) {
+        return this.abstractImplementations.get(abstractClass) ?? [];
+    }
+    hasImplementation(abstractClass) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        return !!implementations && implementations.length > 0;
+    }
+    clearAbstractImplementations() {
+        this.abstractImplementations.clear();
+    }
 }
 exports.Registry = Registry;
 exports.registry = Registry.getInstance();

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;
 }