@riktajs/core 0.4.4 → 0.4.6

package/dist/core/application.d.ts

@@ -1,35 +1,6 @@
 import 'reflect-metadata';
 import { RiktaConfig, RiktaApplication } from './types';
-/**
- * RiktaFactory - Bootstrap the application
- *
- * Creates and initializes the Rikta application with auto-discovery.
- * All classes decorated with @Controller are automatically registered.
- *
- * .env files are loaded automatically at the start of create(), so environment
- * variables are immediately available in your main script.
- */
 export declare class RiktaFactory {
-    /**
-     * Create and bootstrap the application
-     *
-     * .env files are loaded automatically before any initialization,
-     * making environment variables available immediately.
-     *
-     * @example
-     * ```typescript
-     * // Auto-discovery from current directory (default)
-     * // process.env variables are available immediately after this line
-     * const app = await Rikta.create({ port: 3000 });
-     *
-     * // Auto-discovery from specific paths
-     * const app = await Rikta.create({
-     *   autowired: ['./src/controllers', './src/services'],
-     *   port: 3000
-     * });
-     * ```
-     */
     static create(config?: RiktaConfig): Promise<RiktaApplication>;
 }
 export { RiktaFactory as Rikta };
-//# sourceMappingURL=application.d.ts.map

package/dist/core/application.js

@@ -15,45 +15,14 @@ const on_decorator_1 = require("./lifecycle/on.decorator");
 const constants_1 = require("./constants");
 const exceptions_1 = require("./exceptions");
 const env_loader_1 = require("./config/env-loader");
-/**
- * RiktaFactory - Bootstrap the application
- *
- * Creates and initializes the Rikta application with auto-discovery.
- * All classes decorated with @Controller are automatically registered.
- *
- * .env files are loaded automatically at the start of create(), so environment
- * variables are immediately available in your main script.
- */
 class RiktaFactory {
-    /**
-     * Create and bootstrap the application
-     *
-     * .env files are loaded automatically before any initialization,
-     * making environment variables available immediately.
-     *
-     * @example
-     * ```typescript
-     * // Auto-discovery from current directory (default)
-     * // process.env variables are available immediately after this line
-     * const app = await Rikta.create({ port: 3000 });
-     *
-     * // Auto-discovery from specific paths
-     * const app = await Rikta.create({
-     *   autowired: ['./src/controllers', './src/services'],
-     *   port: 3000
-     * });
-     * ```
-     */
     static async create(config = {}) {
-        // Load .env files FIRST, before anything else
-        // This ensures environment variables are available immediately
         (0, env_loader_1.loadEnvFiles)();
         const silent = config.silent ?? false;
         if (!silent)
             console.log('\n🚀 Rikta Framework Starting...\n');
         const callerDir = (0, discovery_1.getCallerDirectory)();
         let discoveredFiles = [];
-        // Auto-discovery: scan for controllers and services
         if (!config.controllers && config.autowired !== false) {
             const patterns = Array.isArray(config.autowired) && config.autowired.length > 0
                 ? config.autowired
@@ -67,9 +36,6 @@ class RiktaFactory {
 }
 exports.RiktaFactory = RiktaFactory;
 exports.Rikta = RiktaFactory;
-/**
- * Internal application implementation
- */
 class RiktaApplicationImpl {
     server;
     container;
@@ -86,7 +52,6 @@ class RiktaApplicationImpl {
         this.config = {
             port: config.port ?? constants_1.DEFAULT_CONFIG.port,
             host: config.host ?? constants_1.DEFAULT_CONFIG.host,
-            // If silent mode, disable logger unless explicitly set
             logger: config.logger ?? (silent ? false : constants_1.DEFAULT_CONFIG.logger),
             prefix: config.prefix ?? constants_1.DEFAULT_CONFIG.prefix,
             silent: silent,
@@ -98,68 +63,46 @@ class RiktaApplicationImpl {
         this.server = (0, fastify_1.default)({ logger: this.config.logger });
         this.container = container_1.Container.getInstance();
         this.router = new router_1.Router(this.server, this.container, this.config.prefix);
-        // Create and register EventBus
         this.events = new event_bus_1.EventBus();
         this.container.registerInstance(event_bus_1.EventBus, this.events);
-        // Setup global exception handler
         this.setupExceptionHandler();
     }
-    /**
-     * Setup global exception handler
-     */
     setupExceptionHandler() {
-        // Create global exception filter with config
-        // When silent mode is enabled, also disable exception logging unless explicitly enabled
         const silent = this.config.silent ?? false;
         const globalFilter = new exceptions_1.GlobalExceptionFilter({
             includeStack: this.config.exceptionFilter?.includeStack,
             logErrors: this.config.exceptionFilter?.logErrors ?? (silent ? false : true),
         });
-        // Register custom exception filters
         const customFilters = this.config.exceptionFilters ?? [];
         for (const FilterClass of customFilters) {
             const metadata = (0, exceptions_1.getCatchMetadata)(FilterClass);
             const filterInstance = this.container.resolve(FilterClass);
             if (metadata && metadata.exceptions.length > 0) {
-                // Register for specific exception types
                 for (const ExceptionType of metadata.exceptions) {
                     this.customExceptionFilters.set(ExceptionType, filterInstance);
                 }
             }
             else {
-                // Catch-all filter (registered as Error)
                 this.customExceptionFilters.set(Error, filterInstance);
             }
         }
-        // Set Fastify error handler
         this.server.setErrorHandler((0, exceptions_1.createExceptionHandler)(globalFilter, this.customExceptionFilters));
     }
-    /**
-     * Initialize the application
-     */
     async init(discoveredFiles = []) {
-        // Note: .env files are already loaded in create() before this point
-        // Emit discovery event
         await this.events.emit('app:discovery', { files: discoveredFiles });
-        // 1. Process config providers (register them in the container)
         await this.processConfigProviders();
-        // 2. Process @Provider classes
         await this.processCustomProviders();
         await this.events.emit('app:providers', {
             count: registry_1.registry.getCustomProviders().length
         });
-        // 3. Get and sort providers by priority
         const providers = this.getSortedProviders();
-        // 3. Register additional explicit providers
         const additionalProviders = this.config.providers ?? [];
         for (const provider of additionalProviders) {
             this.registerProvider(provider);
         }
-        // 4. Initialize all @Injectable providers
         for (const { target, priority } of providers) {
             await this.initializeProvider(target, priority);
         }
-        // 5. Register routes
         const controllers = this.config.controllers ?? registry_1.registry.getControllers();
         if (!this.config.silent)
             console.log('📡 Registering routes:');
@@ -167,7 +110,6 @@ class RiktaApplicationImpl {
             this.router.registerController(controller, this.config.silent);
         }
         await this.events.emit('app:routes', { count: controllers.length });
-        // 6. Call onApplicationBootstrap hooks
         await this.callHook('onApplicationBootstrap');
         await this.events.emit('app:bootstrap', {
             providerCount: this.initializedProviders.length
@@ -175,25 +117,17 @@ class RiktaApplicationImpl {
         if (!this.config.silent)
             console.log('\n✅ Rikta is ready\n');
     }
-    /**
-     * Process all config providers and register them in the container
-     */
     async processConfigProviders() {
         const configProviders = registry_1.registry.getConfigProviderRegistrations();
         if (configProviders.length === 0)
             return;
         for (const { token, providerClass } of configProviders) {
-            // Register the config provider class in the container
-            // This allows it to be resolved via @Autowired(token)
             this.container.registerProvider({
                 provide: token,
                 useClass: providerClass,
             });
         }
     }
-    /**
-     * Process all @Provider decorated classes
-     */
     async processCustomProviders() {
         const customProviders = registry_1.registry.getCustomProviders();
         if (customProviders.length === 0)
@@ -207,9 +141,6 @@ class RiktaApplicationImpl {
             this.container.registerValue(metadata.token, value);
         }
     }
-    /**
-     * Get providers sorted by priority (higher = first)
-     */
     getSortedProviders() {
         const providers = registry_1.registry.getProviders();
         return providers
@@ -219,33 +150,20 @@ class RiktaApplicationImpl {
         }))
             .sort((a, b) => b.priority - a.priority);
     }
-    /**
-     * Get priority from @Injectable() metadata
-     */
     getProviderPriority(target) {
         const options = Reflect.getMetadata(constants_1.INJECTABLE_METADATA, target);
         return options?.priority ?? 0;
     }
-    /**
-     * Initialize a single provider
-     */
     async initializeProvider(target, priority) {
         const instance = this.container.resolve(target);
         const name = target.name;
-        // Track initialized provider
         this.initializedProviders.push({ instance, priority, name });
-        // Call onProviderInit hook
         if (this.hasHook(instance, 'onProviderInit')) {
             await instance.onProviderInit();
         }
-        // Emit provider:init event
         await this.events.emit('provider:init', { provider: target, name, priority });
-        // Register @On() event listeners from this instance
         this.registerEventListeners(target, instance);
     }
-    /**
-     * Register @On() decorated methods as event listeners
-     */
     registerEventListeners(target, instance) {
         const metadata = Reflect.getMetadata(on_decorator_1.ON_EVENT_METADATA, target) ?? [];
         for (const { event, methodName } of metadata) {
@@ -255,17 +173,11 @@ class RiktaApplicationImpl {
             }
         }
     }
-    /**
-     * Register a provider in the container
-     */
     registerProvider(provider) {
         const instance = this.container.resolve(provider);
         const priority = this.getProviderPriority(provider);
         this.initializedProviders.push({ instance, priority, name: provider.name });
     }
-    /**
-     * Call a lifecycle hook on all initialized providers
-     */
     async callHook(hookName) {
         for (const { instance } of this.initializedProviders) {
             if (this.hasHook(instance, hookName)) {
@@ -273,18 +185,12 @@ class RiktaApplicationImpl {
             }
         }
     }
-    /**
-     * Check if an instance has a lifecycle hook
-     */
     hasHook(instance, hookName) {
         return (instance !== null &&
             typeof instance === 'object' &&
             hookName in instance &&
             typeof instance[hookName] === 'function');
     }
-    /**
-     * Start listening for requests
-     */
     async listen() {
         if (this.isListening) {
             return this.address;
@@ -294,56 +200,39 @@ class RiktaApplicationImpl {
             host: this.config.host,
         });
         this.isListening = true;
-        // Call onApplicationListen hooks
         for (const { instance } of this.initializedProviders) {
             if (this.hasHook(instance, 'onApplicationListen')) {
                 await instance.onApplicationListen(this.address);
             }
         }
-        // Emit app:listen event
         await this.events.emit('app:listen', {
             address: this.address,
             port: this.config.port
         });
         return this.address;
     }
-    /**
-     * Close the application
-     */
     async close(signal) {
-        // Emit app:shutdown event
         await this.events.emit('app:shutdown', { signal });
-        // Call hooks in REVERSE priority order
         const reversed = [...this.initializedProviders].reverse();
         for (const { instance } of reversed) {
-            // Call onApplicationShutdown
             if (this.hasHook(instance, 'onApplicationShutdown')) {
                 await instance.onApplicationShutdown(signal);
             }
-            // Call onProviderDestroy
             if (this.hasHook(instance, 'onProviderDestroy')) {
                 await instance.onProviderDestroy();
             }
         }
-        // Close Fastify
         await this.server.close();
         this.isListening = false;
-        // Emit app:destroy event
         await this.events.emit('app:destroy', {
             uptime: Date.now() - this.startTime
         });
         if (!this.config.silent)
             console.log('\n👋 Application closed\n');
     }
-    /**
-     * Get the server URL
-     */
     getUrl() {
         return this.address;
     }
-    /**
-     * Get the EventBus instance
-     */
     getEventBus() {
         return this.events;
     }
@@ -351,4 +240,3 @@ class RiktaApplicationImpl {
         return this.container;
     }
 }
-//# sourceMappingURL=application.js.map

package/dist/core/config/abstract-config-provider.d.ts

@@ -1,148 +1,14 @@
 import { z, ZodSchema } from 'zod';
-/**
- * Exception thrown when config validation fails
- */
 export declare class ConfigValidationException extends Error {
     readonly errors: z.ZodError;
     constructor(errors: z.ZodError, providerName: string);
 }
-/**
- * Abstract base class for configuration providers
- *
- * This class handles:
- * - Validating environment variables against a Zod schema
- * - Populating decorated properties with validated values
- * - Caching validated configuration
- *
- * Note: .env files are loaded automatically at the start of Rikta.create(),
- * so they are available immediately in your main script and before any
- * config provider is instantiated.
- *
- * Child classes must:
- * 1. Extend this class
- * 2. Implement the abstract schema() method
- * 3. Decorate properties with @ConfigProperty()
- * 4. Call populate() in their constructor
- *
- * @example
- * ```typescript
- * import { AbstractConfigProvider, Provider, ConfigProperty } from '@riktajs/core';
- * import { z } from 'zod';
- *
- * @Provider('APP_CONFIG')
- * export class AppConfigProvider extends AbstractConfigProvider {
- *   schema() {
- *     return z.object({
- *       PORT: z.coerce.number().int().min(1).max(65535),
- *       HOST: z.string().default('localhost'),
- *       NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
- *     });
- *   }
- *
- *   @ConfigProperty()
- *   port!: number;
- *
- *   @ConfigProperty()
- *   host!: string;
- *
- *   @ConfigProperty('NODE_ENV')
- *   environment!: 'development' | 'production' | 'test';
- *
- *   constructor() {
- *     super();
- *     this.populate();
- *   }
- * }
- * ```
- */
 export declare abstract class AbstractConfigProvider {
-    /**
-     * Cache for validated configuration
-     * Frozen to prevent accidental mutations
-     */
     private _cache?;
-    /**
-     * Define the Zod schema for this configuration
-     *
-     * @returns A Zod schema that validates the environment variables
-     *
-     * @example
-     * ```typescript
-     * schema() {
-     *   return z.object({
-     *     DATABASE_URL: z.string().url(),
-     *     DB_POOL_SIZE: z.coerce.number().int().min(1).max(100).default(10),
-     *     DB_TIMEOUT: z.coerce.number().int().default(30000),
-     *   });
-     * }
-     * ```
-     */
     protected abstract schema(): ZodSchema;
-    /**
-     * Constructor ensures .env files are loaded (for standalone usage)
-     *
-     * Note: When using Rikta.create(), .env files are loaded automatically
-     * during bootstrap, so this is a safety measure for standalone usage.
-     */
     constructor();
-    /**
-     * Validate and cache the configuration
-     *
-     * This method runs the Zod schema validation against process.env
-     * and caches the result. Subsequent calls return the cached value.
-     *
-     * @returns The validated and frozen configuration object
-     * @throws {ConfigValidationException} If validation fails
-     *
-     * @private
-     */
     private validateAndCache;
-    /**
-     * Populate decorated properties with validated values
-     *
-     * This method reads the @ConfigProperty metadata and assigns
-     * the corresponding validated environment values to class properties.
-     *
-     * Must be called in the child class constructor after super().
-     *
-     * @throws {ConfigValidationException} If validation fails
-     *
-     * @example
-     * ```typescript
-     * constructor() {
-     *   super();
-     *   this.populate(); // Must call this!
-     * }
-     * ```
-     */
     protected populate(): void;
-    /**
-     * Get the raw validated configuration object
-     *
-     * This is useful for accessing config values that aren't mapped
-     * to properties, or for passing the entire config to other services.
-     *
-     * @returns The validated and frozen configuration object
-     *
-     * @example
-     * ```typescript
-     * const config = this.getConfig();
-     * console.log('All env vars:', config);
-     * ```
-     */
     protected getConfig(): Readonly<Record<string, unknown>>;
-    /**
-     * Get a specific configuration value by key
-     *
-     * @param key - The environment variable name
-     * @returns The validated value, or undefined if not found
-     *
-     * @example
-     * ```typescript
-     * const port = this.get<number>('PORT');
-     * const apiKey = this.get<string>('API_KEY');
-     * ```
-     */
     protected get<T = unknown>(key: string): T | undefined;
 }
-//# sourceMappingURL=abstract-config-provider.d.ts.map

package/dist/core/config/abstract-config-provider.js

@@ -4,9 +4,6 @@ exports.AbstractConfigProvider = exports.ConfigValidationException = void 0;
 const zod_1 = require("zod");
 const config_property_decorator_1 = require("../decorators/config-property.decorator");
 const env_loader_1 = require("./env-loader");
-/**
- * Exception thrown when config validation fails
- */
 class ConfigValidationException extends Error {
     errors;
     constructor(errors, providerName) {
@@ -20,82 +17,11 @@ class ConfigValidationException extends Error {
     }
 }
 exports.ConfigValidationException = ConfigValidationException;
-/**
- * Abstract base class for configuration providers
- *
- * This class handles:
- * - Validating environment variables against a Zod schema
- * - Populating decorated properties with validated values
- * - Caching validated configuration
- *
- * Note: .env files are loaded automatically at the start of Rikta.create(),
- * so they are available immediately in your main script and before any
- * config provider is instantiated.
- *
- * Child classes must:
- * 1. Extend this class
- * 2. Implement the abstract schema() method
- * 3. Decorate properties with @ConfigProperty()
- * 4. Call populate() in their constructor
- *
- * @example
- * ```typescript
- * import { AbstractConfigProvider, Provider, ConfigProperty } from '@riktajs/core';
- * import { z } from 'zod';
- *
- * @Provider('APP_CONFIG')
- * export class AppConfigProvider extends AbstractConfigProvider {
- *   schema() {
- *     return z.object({
- *       PORT: z.coerce.number().int().min(1).max(65535),
- *       HOST: z.string().default('localhost'),
- *       NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
- *     });
- *   }
- *
- *   @ConfigProperty()
- *   port!: number;
- *
- *   @ConfigProperty()
- *   host!: string;
- *
- *   @ConfigProperty('NODE_ENV')
- *   environment!: 'development' | 'production' | 'test';
- *
- *   constructor() {
- *     super();
- *     this.populate();
- *   }
- * }
- * ```
- */
 class AbstractConfigProvider {
-    /**
-     * Cache for validated configuration
-     * Frozen to prevent accidental mutations
-     */
     _cache;
-    /**
-     * Constructor ensures .env files are loaded (for standalone usage)
-     *
-     * Note: When using Rikta.create(), .env files are loaded automatically
-     * during bootstrap, so this is a safety measure for standalone usage.
-     */
     constructor() {
-        // Ensure .env files are loaded (idempotent operation)
         (0, env_loader_1.loadEnvFiles)();
     }
-    /**
-     * Validate and cache the configuration
-     *
-     * This method runs the Zod schema validation against process.env
-     * and caches the result. Subsequent calls return the cached value.
-     *
-     * @returns The validated and frozen configuration object
-     * @throws {ConfigValidationException} If validation fails
-     *
-     * @private
-     */
     validateAndCache() {
         if (this._cache) {
             return this._cache;
@@ -103,7 +29,6 @@ class AbstractConfigProvider {
         try {
             const schema = this.schema();
             const validated = schema.parse(process.env);
-            // Freeze the cache to make it immutable (tip from plan)
             this._cache = Object.freeze(validated);
             return this._cache;
         }
@@ -114,69 +39,20 @@ class AbstractConfigProvider {
             throw error;
         }
     }
-    /**
-     * Populate decorated properties with validated values
-     *
-     * This method reads the @ConfigProperty metadata and assigns
-     * the corresponding validated environment values to class properties.
-     *
-     * Must be called in the child class constructor after super().
-     *
-     * @throws {ConfigValidationException} If validation fails
-     *
-     * @example
-     * ```typescript
-     * constructor() {
-     *   super();
-     *   this.populate(); // Must call this!
-     * }
-     * ```
-     */
     populate() {
-        // Validate and get cached config
         const config = this.validateAndCache();
-        // Get property mappings from metadata
         const mappings = (0, config_property_decorator_1.getConfigPropertyMappings)(this.constructor);
-        // Assign values to properties
         for (const mapping of mappings) {
             const value = config[mapping.envKey];
-            // Use type assertion since we know the property exists
             this[mapping.propertyKey] = value;
         }
     }
-    /**
-     * Get the raw validated configuration object
-     *
-     * This is useful for accessing config values that aren't mapped
-     * to properties, or for passing the entire config to other services.
-     *
-     * @returns The validated and frozen configuration object
-     *
-     * @example
-     * ```typescript
-     * const config = this.getConfig();
-     * console.log('All env vars:', config);
-     * ```
-     */
     getConfig() {
         return this.validateAndCache();
     }
-    /**
-     * Get a specific configuration value by key
-     *
-     * @param key - The environment variable name
-     * @returns The validated value, or undefined if not found
-     *
-     * @example
-     * ```typescript
-     * const port = this.get<number>('PORT');
-     * const apiKey = this.get<string>('API_KEY');
-     * ```
-     */
     get(key) {
         const config = this.validateAndCache();
         return config[key];
     }
 }
 exports.AbstractConfigProvider = AbstractConfigProvider;
-//# sourceMappingURL=abstract-config-provider.js.map

package/dist/core/config/env-loader.d.ts

@@ -1,27 +1,3 @@
-/**
- * Load .env files with environment-specific precedence
- *
- * This function is called automatically at the start of Rikta.create(),
- * ensuring environment variables are available immediately in your main
- * script and before any config providers are initialized.
- *
- * You can also call this function manually before Rikta.create() if needed.
- *
- * Loading order (later files override earlier):
- * 1. .env (base configuration)
- * 2. .env.{NODE_ENV} (environment-specific)
- *
- * @internal
- */
 export declare function loadEnvFiles(): void;
-/**
- * Check if .env files have been loaded
- * @internal
- */
 export declare function isEnvLoaded(): boolean;
-/**
- * Reset the env loaded flag (for testing)
- * @internal
- */
 export declare function resetEnvLoaded(): void;
-//# sourceMappingURL=env-loader.d.ts.map