@riktajs/core 0.4.4 → 0.4.6

package/dist/core/registry.js

@@ -2,25 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Registry = exports.registry = void 0;
 const config_exceptions_1 = require("./exceptions/config.exceptions");
-/**
- * Global Registry
- *
- * Stores references to all decorated classes for auto-discovery.
- * Controllers and providers register themselves here via decorators.
- *
- * The registry acts as a collection point during the decoration phase.
- * Once the application initializes, the registered classes are processed
- * and transferred to the DI container for resolution.
- */
 class Registry {
     static instance;
-    /** All registered controllers */
     controllers = new Set();
-    /** All registered providers (services via @Injectable) */
     providers = new Set();
-    /** All registered custom providers (via @Provider) */
     customProviders = new Set();
-    /** Map of config provider tokens to their class constructors */
     configProviderMap = new Map();
     constructor() { }
     static getInstance() {
@@ -29,82 +15,37 @@ class Registry {
         }
         return Registry.instance;
     }
-    /**
-     * Reset the registry (useful for testing)
-     */
     static reset() {
         const newInstance = new Registry();
         Registry.instance = newInstance;
     }
-    /**
-     * Register a controller
-     */
     registerController(target) {
         this.controllers.add(target);
     }
-    /**
-     * Register a provider
-     */
     registerProvider(target) {
         this.providers.add(target);
     }
-    /**
-     * Get all registered controllers
-     */
     getControllers() {
         return [...this.controllers];
     }
-    /**
-     * Get all registered providers
-     */
     getProviders() {
         return [...this.providers];
     }
-    /**
-     * Check if a controller is registered
-     */
     hasController(target) {
         return this.controllers.has(target);
     }
-    /**
-     * Check if a provider is registered
-     */
     hasProvider(target) {
         return this.providers.has(target);
     }
-    /**
-     * Register a custom provider (@Provider)
-     */
     registerCustomProvider(target) {
         this.customProviders.add(target);
     }
-    /**
-     * Get all registered custom providers
-     */
     getCustomProviders() {
         return [...this.customProviders];
     }
-    /**
-     * Check if a custom provider is registered
-     */
     hasCustomProvider(target) {
         return this.customProviders.has(target);
     }
-    // ============================================================================
-    // Config Provider Methods
-    // ============================================================================
-    /**
-     * Register a config provider with its injection token
-     *
-     * @param token - The injection token (e.g., 'APP_CONFIG')
-     * @param providerClass - The config provider class constructor
-     * @throws {ConfigProviderAlreadyRegisteredException} If the token is already registered
-     *
-     * @example
-     * ```typescript
-     * registry.registerConfigProvider('APP_CONFIG', AppConfigProvider);
-     * ```
-     */
     registerConfigProvider(token, providerClass) {
         if (this.configProviderMap.has(token)) {
             const existingClass = this.configProviderMap.get(token);
@@ -112,33 +53,15 @@ class Registry {
         }
         this.configProviderMap.set(token, providerClass);
     }
-    /**
-     * Get all registered config provider classes with their tokens
-     *
-     * @returns Array of registration info objects
-     *
-     * @internal Used by auto-discovery mechanism
-     */
     getConfigProviderRegistrations() {
         return Array.from(this.configProviderMap.entries()).map(([token, providerClass]) => ({
             token,
             providerClass,
         }));
     }
-    /**
-     * Clear all config provider registrations (useful for testing)
-     *
-     * This will remove all registered config providers
-     *
-     * @internal
-     */
     clearConfigProviders() {
         this.configProviderMap.clear();
     }
 }
 exports.Registry = Registry;
-/**
- * Global registry instance
- */
 exports.registry = Registry.getInstance();
-//# sourceMappingURL=registry.js.map

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

@@ -2,59 +2,18 @@ import 'reflect-metadata';
 import { FastifyInstance } from 'fastify';
 import { Container } from '../container/container';
 import { Constructor } from '../types';
-/**
- * Router class
- *
- * Responsible for:
- * - Scanning controllers for route metadata
- * - Registering routes with Fastify
- * - Handling parameter injection
- *
- * Performance optimizations:
- * - Pre-compiled parameter extractors
- * - Guard instance caching
- * - Fast path for simple routes
- */
 export declare class Router {
     private readonly server;
     private readonly container;
     private readonly globalPrefix;
-    /** Cache for guard instances (singleton per guard class) */
     private readonly guardCache;
     constructor(server: FastifyInstance, container: Container, globalPrefix?: string);
-    /**
-     * Register all routes from a controller
-     */
     registerController(controllerClass: Constructor, silent?: boolean): void;
-    /**
-     * Register a single route
-     */
     private registerRoute;
-    /**
-     * OPTIMIZATION: Compile parameter resolvers at route registration time
-     * Each resolver is a pre-built extractor function
-     */
     private compileParamResolvers;
-    /**
-     * OPTIMIZATION: Create a specialized extractor function for each param type
-     * This avoids switch statements at runtime
-     */
     private createParamExtractor;
-    /**
-     * OPTIMIZATION: Resolve params using pre-compiled extractors
-     */
     private resolveParamsOptimized;
-    /**
-     * OPTIMIZATION: Pre-resolve guard instances at route registration
-     */
     private resolveGuardInstances;
-    /**
-     * OPTIMIZATION: Execute guards using pre-resolved instances
-     */
     private executeGuardsOptimized;
-    /**
-     * Build the full route path
-     */
     private buildPath;
 }
-//# sourceMappingURL=router.d.ts.map

package/dist/core/router/router.js

@@ -7,89 +7,49 @@ const validation_exception_1 = require("../exceptions/validation.exception");
 const exceptions_1 = require("../exceptions/exceptions");
 const execution_context_1 = require("../guards/execution-context");
 const use_guards_decorator_1 = require("../guards/use-guards.decorator");
-/**
- * Router class
- *
- * Responsible for:
- * - Scanning controllers for route metadata
- * - Registering routes with Fastify
- * - Handling parameter injection
- *
- * Performance optimizations:
- * - Pre-compiled parameter extractors
- * - Guard instance caching
- * - Fast path for simple routes
- */
 class Router {
     server;
     container;
     globalPrefix;
-    /** Cache for guard instances (singleton per guard class) */
     guardCache = new Map();
     constructor(server, container, globalPrefix = '') {
         this.server = server;
         this.container = container;
         this.globalPrefix = globalPrefix;
     }
-    /**
-     * Register all routes from a controller
-     */
     registerController(controllerClass, silent = false) {
-        // Get controller metadata
         const controllerMeta = Reflect.getMetadata(constants_1.CONTROLLER_METADATA, controllerClass);
         if (!controllerMeta) {
             throw new Error(`${controllerClass.name} is not decorated with @Controller(). ` +
                 `Make sure to add the decorator.`);
         }
-        // Resolve controller instance from container
         const controllerInstance = this.container.resolve(controllerClass);
-        // Get routes metadata
         const routes = Reflect.getMetadata(constants_1.ROUTES_METADATA, controllerClass) ?? [];
-        // Register each route
         for (const route of routes) {
             this.registerRoute(controllerClass, controllerInstance, controllerMeta.prefix, route, silent);
         }
     }
-    /**
-     * Register a single route
-     */
     registerRoute(controllerClass, controllerInstance, controllerPrefix, route, silent = false) {
-        // Build full path
         const fullPath = this.buildPath(controllerPrefix, route.path);
-        // Get the handler method
         const handler = controllerInstance[route.handlerName];
         if (typeof handler !== 'function') {
             throw new Error(`Handler ${String(route.handlerName)} not found on ${controllerClass.name}`);
         }
-        // Get parameter metadata
         const paramsMeta = Reflect.getMetadata(constants_1.PARAM_METADATA, controllerClass, route.handlerName) ?? [];
-        // Get HTTP status code if set
         const statusCode = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, controllerClass, route.handlerName);
-        // Get guards for this route (controller-level + method-level)
         const guards = (0, use_guards_decorator_1.getGuardsMetadata)(controllerClass, route.handlerName);
-        // ============================================
-        // OPTIMIZATION: Pre-compile parameter resolvers
-        // ============================================
         const compiledResolvers = this.compileParamResolvers(paramsMeta);
         const hasParams = compiledResolvers.length > 0;
         const maxParamIndex = hasParams ? Math.max(...compiledResolvers.map(r => r.index)) : -1;
-        // ============================================
-        // OPTIMIZATION: Pre-resolve guard instances
-        // ============================================
         const guardInstances = this.resolveGuardInstances(guards);
         const hasGuards = guardInstances.length > 0;
-        // ============================================
-        // OPTIMIZATION: Create specialized handlers
-        // ============================================
         let routeHandler;
         if (!hasGuards && !hasParams && !statusCode) {
-            // FAST PATH: No guards, no params, no custom status
             routeHandler = async (_request, _reply) => {
                 return handler.call(controllerInstance);
             };
         }
         else if (!hasGuards && !hasParams) {
-            // Fast path: Just status code
             routeHandler = async (_request, reply) => {
                 const result = await handler.call(controllerInstance);
                 if (statusCode)
@@ -98,7 +58,6 @@ class Router {
             };
         }
         else if (!hasGuards) {
-            // Medium path: Params but no guards
             routeHandler = async (request, reply) => {
                 const args = this.resolveParamsOptimized(compiledResolvers, maxParamIndex, request, reply);
                 const result = await handler.apply(controllerInstance, args);
@@ -108,13 +67,9 @@ class Router {
             };
         }
         else {
-            // Full path: Guards + params
-            // Pre-create execution context factory for this route
             const createContext = (req, rep) => new execution_context_1.ExecutionContextImpl(req, rep, controllerClass, route.handlerName);
             routeHandler = async (request, reply) => {
-                // Execute guards with cached instances
                 await this.executeGuardsOptimized(guardInstances, createContext(request, reply));
-                // Resolve params if needed
                 const args = hasParams
                     ? this.resolveParamsOptimized(compiledResolvers, maxParamIndex, request, reply)
                     : [];
@@ -124,17 +79,11 @@ class Router {
                 return result;
             };
         }
-        // Register with Fastify
         const method = route.method.toLowerCase();
         this.server[method](fullPath, routeHandler);
-        // Log route registration
         if (!silent)
             console.log(`  → ${route.method.padEnd(7)} ${fullPath}`);
     }
-    /**
-     * OPTIMIZATION: Compile parameter resolvers at route registration time
-     * Each resolver is a pre-built extractor function
-     */
     compileParamResolvers(paramsMeta) {
         if (paramsMeta.length === 0)
             return [];
@@ -148,10 +97,6 @@ class Router {
             };
         });
     }
-    /**
-     * OPTIMIZATION: Create a specialized extractor function for each param type
-     * This avoids switch statements at runtime
-     */
     createParamExtractor(param) {
         const key = param.key;
         switch (param.type) {
@@ -182,11 +127,7 @@ class Router {
                 return () => undefined;
         }
     }
-    /**
-     * OPTIMIZATION: Resolve params using pre-compiled extractors
-     */
     resolveParamsOptimized(resolvers, maxIndex, request, reply) {
-        // Build context once
         const context = {
             request,
             reply,
@@ -194,12 +135,10 @@ class Router {
             query: request.query,
             body: request.body,
         };
-        // Pre-allocate array
         const args = new Array(maxIndex + 1);
         for (let i = 0; i < resolvers.length; i++) {
             const resolver = resolvers[i];
             let value = resolver.extract(context);
-            // Validate if schema present
             if (resolver.zodSchema) {
                 const result = resolver.zodSchema.safeParse(value);
                 if (!result.success) {
@@ -211,16 +150,11 @@ class Router {
         }
         return args;
     }
-    /**
-     * OPTIMIZATION: Pre-resolve guard instances at route registration
-     */
     resolveGuardInstances(guards) {
         return guards.map(GuardClass => {
-            // Check cache first
             let instance = this.guardCache.get(GuardClass);
             if (instance)
                 return instance;
-            // Resolve from container
             try {
                 instance = this.container.resolve(GuardClass);
             }
@@ -229,19 +163,14 @@ class Router {
                     `Make sure it is decorated with @Injectable(). ` +
                     `Original error: ${error instanceof Error ? error.message : String(error)}`);
             }
-            // Verify interface
             if (typeof instance.canActivate !== 'function') {
                 throw new Error(`${GuardClass.name} does not implement CanActivate interface. ` +
                     `The guard must have a canActivate(context: ExecutionContext) method.`);
             }
-            // Cache for future use
             this.guardCache.set(GuardClass, instance);
             return instance;
         });
     }
-    /**
-     * OPTIMIZATION: Execute guards using pre-resolved instances
-     */
     async executeGuardsOptimized(guardInstances, context) {
         for (let i = 0; i < guardInstances.length; i++) {
             const result = await guardInstances[i].canActivate(context);
@@ -250,16 +179,11 @@ class Router {
             }
         }
     }
-    /**
-     * Build the full route path
-     */
     buildPath(controllerPrefix, routePath) {
         const parts = [this.globalPrefix, controllerPrefix, routePath]
             .filter(Boolean)
             .join('');
-        // Normalize multiple slashes
         return parts.replace(/\/+/g, '/') || '/';
     }
 }
 exports.Router = Router;
-//# sourceMappingURL=router.js.map

package/dist/core/types.d.ts

@@ -1,16 +1,7 @@
 import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
 import { Container } from "@rikta/core/container";
-/**
- * Constructor type for class instantiation
- */
 export type Constructor<T = any> = new (...args: any[]) => T;
-/**
- * HTTP methods supported by the framework
- */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
-/**
- * Route handler context
- */
 export interface RouteContext {
     request: FastifyRequest;
     reply: FastifyReply;
@@ -18,143 +9,44 @@ export interface RouteContext {
     query: Record<string, unknown>;
     body: unknown;
 }
-/**
- * Route definition metadata
- */
 export interface RouteDefinition {
     method: HttpMethod;
     path: string;
     handlerName: string | symbol;
     statusCode?: number;
 }
-/**
- * Controller metadata
- */
 export interface ControllerMetadata {
     prefix: string;
     routes: RouteDefinition[];
 }
-/**
- * Provider scope for dependency injection
- */
 export type ProviderScope = 'singleton' | 'transient' | 'request';
-/**
- * Injectable options
- */
 export interface InjectableOptions {
-    /** Provider scope (default: 'singleton') */
     scope?: ProviderScope;
-    /**
-     * Initialization priority (higher = initialized first)
-     * Default: 0
-     *
-     * @example
-     * ```typescript
-     * @Injectable({ priority: 100 })
-     * class DatabaseService { }  // Initialized first
-     *
-     * @Injectable({ priority: 50 })
-     * class CacheService { }     // Initialized second
-     *
-     * @Injectable()  // priority: 0
-     * class UserService { }      // Initialized last
-     * ```
-     */
     priority?: number;
 }
-/**
- * Exception filter options
- */
 export interface ExceptionFilterConfig {
-    /** Include stack trace in error response (default: true in development) */
     includeStack?: boolean;
-    /** Log errors to console (default: true) */
     logErrors?: boolean;
 }
-/**
- * Application configuration
- */
 export interface RiktaConfig {
-    /** Server port (default: 3000) */
     port?: number;
-    /** Server host (default: '0.0.0.0') */
     host?: string;
-    /** Enable Fastify logging (default: true) */
     logger?: boolean | object;
-    /** Disable all framework console output (default: false) */
     silent?: boolean;
-    /** Global route prefix (default: '') */
     prefix?: string;
-    /**
-     * Glob patterns for auto-discovery of controllers and services.
-     * Files matching these patterns will be imported automatically.
-     *
-     * @default ['./**'] (scans current directory recursively)
-     *
-     * @example
-     * ```typescript
-     * // Scan specific directories
-     * autowired: ['./src/controllers', './src/services']
-     *
-     * // Scan with glob patterns
-     * autowired: ['./src/**\/*.controller.ts', './src/**\/*.service.ts']
-     * ```
-     */
     autowired?: string[] | false;
-    /**
-     * Explicit list of controllers to register.
-     * If not provided, all @Controller decorated classes are auto-discovered.
-     */
     controllers?: Constructor[];
-    /**
-     * Additional providers to register.
-     * Most providers are auto-discovered via @Injectable.
-     * Use this for custom providers or manual registration.
-     */
     providers?: Constructor[];
-    /**
-     * Exception filter configuration.
-     * Controls how errors are handled and formatted.
-     *
-     * @example
-     * ```typescript
-     * exceptionFilter: {
-     *   includeStack: process.env.NODE_ENV !== 'production',
-     *   logErrors: true
-     * }
-     * ```
-     */
     exceptionFilter?: ExceptionFilterConfig;
-    /**
-     * Custom exception filters.
-     * Filters are matched against exception types in order.
-     *
-     * @example
-     * ```typescript
-     * exceptionFilters: [ValidationExceptionFilter, CustomErrorFilter]
-     * ```
-     */
     exceptionFilters?: Constructor[];
 }
-/**
- * Middleware function signature
- */
 export type MiddlewareFunction = (request: FastifyRequest, reply: FastifyReply, next: () => Promise<void>) => Promise<void> | void;
-/**
- * Guard interface for route protection
- */
 export interface Guard {
     canActivate(context: RouteContext): boolean | Promise<boolean>;
 }
-/**
- * Interceptor interface for request/response manipulation
- */
 export interface Interceptor {
     intercept(context: RouteContext, next: () => Promise<unknown>): Promise<unknown>;
 }
-/**
- * Application instance interface
- */
 export interface RiktaApplication {
     readonly server: FastifyInstance;
     listen(): Promise<string>;
@@ -162,4 +54,3 @@ export interface RiktaApplication {
     getUrl(): string;
     getContainer(): Container;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/index.d.ts

@@ -1,44 +1,2 @@
-/**
- * Rikta Framework
- *
- * A modern TypeScript backend framework with zero-config autowiring, powered by Fastify.
- *
- * Features:
- * - Decorator-based routing (@Controller, @Get, @Post, etc.)
- * - Full Autowiring - No modules needed, everything is auto-discovered
- * - Single DI decorator - @Autowired() for constructor and property injection
- * - Hybrid Lifecycle - Interface hooks + EventBus
- * - Exception Handling - Built-in filters with standardized JSON responses
- * - Fastify under the hood for maximum performance
- * - Full TypeScript support
- *
- * @example
- * ```typescript
- * import { Rikta, Controller, Get, Injectable, Autowired } from '@rikta/core';
- *
- * @Injectable()
- * class GreetingService {
- *   getGreeting(): string {
- *     return 'Hello from Rikta!';
- *   }
- * }
- *
- * @Controller()
- * class AppController {
- *   @Autowired()
- *   private greetingService!: GreetingService;
- *
- *   @Get('/')
- *   getHello() {
- *     return this.greetingService.getGreeting();
- *   }
- * }
- *
- * // No modules - just create and run!
- * const app = await Rikta.create({ port: 3000 });
- * await app.listen();
- * ```
- */
 export * from './core';
 export { RiktaFactory as default } from './core/application';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,45 +1,4 @@
 "use strict";
-/**
- * Rikta Framework
- *
- * A modern TypeScript backend framework with zero-config autowiring, powered by Fastify.
- *
- * Features:
- * - Decorator-based routing (@Controller, @Get, @Post, etc.)
- * - Full Autowiring - No modules needed, everything is auto-discovered
- * - Single DI decorator - @Autowired() for constructor and property injection
- * - Hybrid Lifecycle - Interface hooks + EventBus
- * - Exception Handling - Built-in filters with standardized JSON responses
- * - Fastify under the hood for maximum performance
- * - Full TypeScript support
- *
- * @example
- * ```typescript
- * import { Rikta, Controller, Get, Injectable, Autowired } from '@rikta/core';
- *
- * @Injectable()
- * class GreetingService {
- *   getGreeting(): string {
- *     return 'Hello from Rikta!';
- *   }
- * }
- *
- * @Controller()
- * class AppController {
- *   @Autowired()
- *   private greetingService!: GreetingService;
- *
- *   @Get('/')
- *   getHello() {
- *     return this.greetingService.getGreeting();
- *   }
- * }
- *
- * // No modules - just create and run!
- * const app = await Rikta.create({ port: 3000 });
- * await app.listen();
- * ```
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -56,9 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = void 0;
-// Re-export everything from core
 __exportStar(require("./core"), exports);
-// Default export for convenience
 var application_1 = require("./core/application");
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return application_1.RiktaFactory; } });
-//# sourceMappingURL=index.js.map