@riktajs/core 0.4.5 → 0.4.6

package/dist/core/decorators/route.decorator.d.ts

@@ -1,53 +1,9 @@
 import 'reflect-metadata';
-/**
- * @Get() decorator - Handles HTTP GET requests
- *
- * @example
- * ```typescript
- * @Get('/users')
- * getUsers() { return []; }
- * ```
- */
 export declare const Get: (path?: string) => MethodDecorator;
-/**
- * @Post() decorator - Handles HTTP POST requests
- *
- * @example
- * ```typescript
- * @Post('/users')
- * createUser(@Body() data: CreateUserDto) { return data; }
- * ```
- */
 export declare const Post: (path?: string) => MethodDecorator;
-/**
- * @Put() decorator - Handles HTTP PUT requests
- */
 export declare const Put: (path?: string) => MethodDecorator;
-/**
- * @Patch() decorator - Handles HTTP PATCH requests
- */
 export declare const Patch: (path?: string) => MethodDecorator;
-/**
- * @Delete() decorator - Handles HTTP DELETE requests
- */
 export declare const Delete: (path?: string) => MethodDecorator;
-/**
- * @Options() decorator - Handles HTTP OPTIONS requests
- */
 export declare const Options: (path?: string) => MethodDecorator;
-/**
- * @Head() decorator - Handles HTTP HEAD requests
- */
 export declare const Head: (path?: string) => MethodDecorator;
-/**
- * @HttpCode() decorator - Sets the HTTP status code for a route
- *
- * @example
- * ```typescript
- * @Post('/users')
- * @HttpCode(201)
- * createUser() { return { created: true }; }
- * ```
- */
 export declare function HttpCode(statusCode: number): MethodDecorator;
-//# sourceMappingURL=route.decorator.d.ts.map

package/dist/core/decorators/route.decorator.js

@@ -4,82 +4,31 @@ exports.Head = exports.Options = exports.Delete = exports.Patch = exports.Put =
 exports.HttpCode = HttpCode;
 require("reflect-metadata");
 const constants_1 = require("../constants");
-/**
- * Creates a route decorator for a specific HTTP method
- */
 function createRouteDecorator(method) {
     return (path = '') => {
         return (target, propertyKey, descriptor) => {
-            // Normalize path
             const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-            // Get existing routes or initialize empty array
             const routes = Reflect.getMetadata(constants_1.ROUTES_METADATA, target.constructor) ?? [];
-            // Add this route
             routes.push({
                 method,
                 path: normalizedPath === '/' ? '' : normalizedPath,
                 handlerName: propertyKey,
             });
-            // Store updated routes
             Reflect.defineMetadata(constants_1.ROUTES_METADATA, routes, target.constructor);
             return descriptor;
         };
     };
 }
-/**
- * @Get() decorator - Handles HTTP GET requests
- *
- * @example
- * ```typescript
- * @Get('/users')
- * getUsers() { return []; }
- * ```
- */
 exports.Get = createRouteDecorator('GET');
-/**
- * @Post() decorator - Handles HTTP POST requests
- *
- * @example
- * ```typescript
- * @Post('/users')
- * createUser(@Body() data: CreateUserDto) { return data; }
- * ```
- */
 exports.Post = createRouteDecorator('POST');
-/**
- * @Put() decorator - Handles HTTP PUT requests
- */
 exports.Put = createRouteDecorator('PUT');
-/**
- * @Patch() decorator - Handles HTTP PATCH requests
- */
 exports.Patch = createRouteDecorator('PATCH');
-/**
- * @Delete() decorator - Handles HTTP DELETE requests
- */
 exports.Delete = createRouteDecorator('DELETE');
-/**
- * @Options() decorator - Handles HTTP OPTIONS requests
- */
 exports.Options = createRouteDecorator('OPTIONS');
-/**
- * @Head() decorator - Handles HTTP HEAD requests
- */
 exports.Head = createRouteDecorator('HEAD');
-/**
- * @HttpCode() decorator - Sets the HTTP status code for a route
- *
- * @example
- * ```typescript
- * @Post('/users')
- * @HttpCode(201)
- * createUser() { return { created: true }; }
- * ```
- */
 function HttpCode(statusCode) {
     return (target, propertyKey, descriptor) => {
         Reflect.defineMetadata(constants_1.HTTP_CODE_METADATA, statusCode, target.constructor, propertyKey);
         return descriptor;
     };
 }
-//# sourceMappingURL=route.decorator.js.map

package/dist/core/discovery.d.ts

@@ -1,35 +1,2 @@
-/**
- * Discover and import modules matching the given patterns
- *
- * Only imports files that contain @Controller, @Injectable, or @Provider decorators.
- *
- * @param patterns - Glob patterns or directory paths to search for files (default: ['./**'])
- * @param cwd - Base directory for pattern matching. If not provided, it will be
- *              automatically resolved from the caller's location (useful when rikta-core
- *              is used as an external library from node_modules)
- * @returns Promise resolving to list of imported files
- *
- * @example
- * ```typescript
- * // Scan specific directories (relative paths resolved from caller's location)
- * await discoverModules(['./src/controllers', './src/services']);
- *
- * // Scan with absolute path
- * await discoverModules(['/absolute/path/to/src']);
- *
- * // Scan everything (default)
- * await discoverModules();
- * ```
- */
 export declare function discoverModules(patterns?: string[], cwd?: string): Promise<string[]>;
-/**
- * Get the entry point directory (where the main script is located)
- *
- * This uses process.argv[1] to determine the directory of the script
- * that started the Node.js process. This works correctly when rikta-core
- * is installed as an external library in node_modules.
- *
- * @returns The directory of the main script, or process.cwd() as fallback
- */
 export declare function getCallerDirectory(): string;
-//# sourceMappingURL=discovery.d.ts.map

package/dist/core/discovery.js

@@ -41,9 +41,6 @@ exports.getCallerDirectory = getCallerDirectory;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-/**
- * Default patterns to exclude from discovery
- */
 const DEFAULT_IGNORE_PATTERNS = [
     '**/node_modules/**',
     '**/dist/**',
@@ -53,46 +50,26 @@ const DEFAULT_IGNORE_PATTERNS = [
     '**/*.spec.ts',
     '**/*.d.ts',
 ];
-/**
- * Get the entry point directory of the application.
- *
- * Uses process.argv[1] which contains the path to the main script being executed.
- * This is the cleanest way to determine the user's project directory when
- * rikta-core is installed in node_modules.
- *
- * Falls back to process.cwd() if argv[1] is not available.
- */
 function getEntryPointDirectory() {
     const mainScript = process.argv[1];
     if (mainScript) {
-        // Handle file:// URLs (ESM) and regular paths
         const filePath = mainScript.startsWith('file://')
             ? new URL(mainScript).pathname
             : mainScript;
         return path_1.default.dirname(filePath);
     }
-    // Fallback to current working directory
     return process.cwd();
 }
-/**
- * Regex patterns to detect Rikta decorators
- * Supports both TypeScript source and compiled JavaScript patterns
- */
 const DECORATOR_PATTERNS = [
-    // TypeScript source patterns
-    /@Controller\s*\(/, // @Controller() or @Controller('/path')
-    /@Injectable\s*\(/, // @Injectable() or @Injectable({ scope: 'singleton' })
-    /@Provider\s*\(/, // @Provider(TOKEN)
-    /@Provider\s*\(/, // @Provider(TOKEN)
-    // Compiled JavaScript patterns (e.g., (0, core_1.Controller)('/path'))
+    /@Controller\s*\(/,
+    /@Injectable\s*\(/,
+    /@Provider\s*\(/,
+    /@Provider\s*\(/,
     /\.\s*Controller\s*\)\s*\(/,
     /\.\s*Injectable\s*\)\s*\(/,
     /\.\s*Provider\s*\)\s*\(/,
     /\.\s*ProviderConfig\s*\)\s*\(/,
 ];
-/**
- * Check if a file contains Rikta decorators (@Controller, @Injectable, or @Provider)
- */
 async function containsRiktaDecorators(filePath) {
     try {
         const content = await promises_1.default.readFile(filePath, 'utf-8');
@@ -102,83 +79,46 @@ async function containsRiktaDecorators(filePath) {
         return false;
     }
 }
-/**
- * Discover and import modules matching the given patterns
- *
- * Only imports files that contain @Controller, @Injectable, or @Provider decorators.
- *
- * @param patterns - Glob patterns or directory paths to search for files (default: ['./**'])
- * @param cwd - Base directory for pattern matching. If not provided, it will be
- *              automatically resolved from the caller's location (useful when rikta-core
- *              is used as an external library from node_modules)
- * @returns Promise resolving to list of imported files
- *
- * @example
- * ```typescript
- * // Scan specific directories (relative paths resolved from caller's location)
- * await discoverModules(['./src/controllers', './src/services']);
- *
- * // Scan with absolute path
- * await discoverModules(['/absolute/path/to/src']);
- *
- * // Scan everything (default)
- * await discoverModules();
- * ```
- */
 async function discoverModules(patterns = ['./**/*.{ts,js}'], cwd) {
-    // If no cwd provided, use the entry point directory (where the main script is)
-    // This is crucial when rikta-core is installed in node_modules
     const baseDir = cwd ?? getEntryPointDirectory();
-    // Resolve the base directory to absolute if needed
     const absoluteBaseDir = path_1.default.isAbsolute(baseDir)
         ? baseDir
         : path_1.default.resolve(process.cwd(), baseDir);
-    // Normalize patterns to include file extensions if not present
     const normalizedPatterns = patterns.map(pattern => {
-        // Resolve the pattern if it's an absolute path
-        // For absolute paths, we need to make them relative to cwd for fast-glob
         let normalizedPattern = pattern;
         if (path_1.default.isAbsolute(pattern)) {
-            // Convert absolute path to relative from baseDir
             normalizedPattern = path_1.default.relative(absoluteBaseDir, pattern);
             if (!normalizedPattern.startsWith('.')) {
                 normalizedPattern = './' + normalizedPattern;
             }
         }
-        // If pattern already has extension, use as-is
         if (/\.\w+$/.test(normalizedPattern) || normalizedPattern.endsWith('*')) {
             return normalizedPattern;
         }
-        // Add file extension pattern
         return normalizedPattern.endsWith('/')
             ? `${normalizedPattern}**/*.{ts,js}`
             : `${normalizedPattern}/**/*.{ts,js}`;
     });
-    // Find all matching files
     const files = await (0, fast_glob_1.default)(normalizedPatterns, {
         cwd: absoluteBaseDir,
         absolute: true,
         ignore: DEFAULT_IGNORE_PATTERNS,
         onlyFiles: true,
     });
-    // Filter files that contain Rikta decorators
     const riktaFiles = [];
     for (const file of files) {
         if (await containsRiktaDecorators(file)) {
             riktaFiles.push(file);
         }
     }
-    // Import only files with decorators
     const importedFiles = [];
     for (const file of riktaFiles) {
         try {
-            // Convert to proper import path
             const importPath = file.replace(/\.ts$/, '');
             await Promise.resolve(`${importPath}`).then(s => __importStar(require(s)));
             importedFiles.push(file);
         }
         catch (error) {
-            // Log but don't fail - some files might have import errors
             if (process.env.DEBUG) {
                 console.warn(`[Rikta] Failed to import ${file}:`, error);
             }
@@ -186,16 +126,6 @@ async function discoverModules(patterns = ['./**/*.{ts,js}'], cwd) {
     }
     return importedFiles;
 }
-/**
- * Get the entry point directory (where the main script is located)
- *
- * This uses process.argv[1] to determine the directory of the script
- * that started the Node.js process. This works correctly when rikta-core
- * is installed as an external library in node_modules.
- *
- * @returns The directory of the main script, or process.cwd() as fallback
- */
 function getCallerDirectory() {
     return getEntryPointDirectory();
 }
-//# sourceMappingURL=discovery.js.map

package/dist/core/exceptions/catch.decorator.d.ts

@@ -1,71 +1,8 @@
 import 'reflect-metadata';
 import { Constructor } from '../types';
-/**
- * Metadata key for @Catch() decorator
- */
 export declare const CATCH_METADATA: unique symbol;
-/**
- * Metadata stored by @Catch() decorator
- */
 export interface CatchMetadata {
-    /** Exception types this filter handles */
     exceptions: Constructor<Error>[];
 }
-/**
- * @Catch() Decorator
- *
- * Marks a class as an exception filter and specifies which
- * exception types it should handle.
- *
- * If no exception types are provided, the filter catches all exceptions.
- *
- * @param exceptions - Exception types to catch (optional)
- *
- * @example Catch specific exception
- * ```typescript
- * @Catch(NotFoundException)
- * class NotFoundExceptionFilter implements ExceptionFilter {
- *   catch(exception: NotFoundException, context: ExceptionContext) {
- *     const { reply, path } = context;
- *     reply.status(404).send({
- *       statusCode: 404,
- *       message: exception.message,
- *       path,
- *       timestamp: new Date().toISOString()
- *     });
- *   }
- * }
- * ```
- *
- * @example Catch multiple exceptions
- * ```typescript
- * @Catch(BadRequestException, UnprocessableEntityException)
- * class ValidationExceptionFilter implements ExceptionFilter {
- *   catch(exception: HttpException, context: ExceptionContext) {
- *     const { reply } = context;
- *     const response = exception.getResponse();
- *
- *     reply.status(exception.getStatus()).send({
- *       ...response,
- *       type: 'VALIDATION_ERROR'
- *     });
- *   }
- * }
- * ```
- *
- * @example Catch all exceptions
- * ```typescript
- * @Catch()
- * class AllExceptionsFilter implements ExceptionFilter {
- *   catch(exception: Error, context: ExceptionContext) {
- *     // Handle any exception
- *   }
- * }
- * ```
- */
 export declare function Catch(...exceptions: Constructor<Error>[]): ClassDecorator;
-/**
- * Get catch metadata from a filter class
- */
 export declare function getCatchMetadata(target: Constructor): CatchMetadata | undefined;
-//# sourceMappingURL=catch.decorator.d.ts.map

package/dist/core/exceptions/catch.decorator.js

@@ -4,62 +4,7 @@ exports.CATCH_METADATA = void 0;
 exports.Catch = Catch;
 exports.getCatchMetadata = getCatchMetadata;
 require("reflect-metadata");
-/**
- * Metadata key for @Catch() decorator
- */
 exports.CATCH_METADATA = Symbol('catch:metadata');
-/**
- * @Catch() Decorator
- *
- * Marks a class as an exception filter and specifies which
- * exception types it should handle.
- *
- * If no exception types are provided, the filter catches all exceptions.
- *
- * @param exceptions - Exception types to catch (optional)
- *
- * @example Catch specific exception
- * ```typescript
- * @Catch(NotFoundException)
- * class NotFoundExceptionFilter implements ExceptionFilter {
- *   catch(exception: NotFoundException, context: ExceptionContext) {
- *     const { reply, path } = context;
- *     reply.status(404).send({
- *       statusCode: 404,
- *       message: exception.message,
- *       path,
- *       timestamp: new Date().toISOString()
- *     });
- *   }
- * }
- * ```
- *
- * @example Catch multiple exceptions
- * ```typescript
- * @Catch(BadRequestException, UnprocessableEntityException)
- * class ValidationExceptionFilter implements ExceptionFilter {
- *   catch(exception: HttpException, context: ExceptionContext) {
- *     const { reply } = context;
- *     const response = exception.getResponse();
- *
- *     reply.status(exception.getStatus()).send({
- *       ...response,
- *       type: 'VALIDATION_ERROR'
- *     });
- *   }
- * }
- * ```
- *
- * @example Catch all exceptions
- * ```typescript
- * @Catch()
- * class AllExceptionsFilter implements ExceptionFilter {
- *   catch(exception: Error, context: ExceptionContext) {
- *     // Handle any exception
- *   }
- * }
- * ```
- */
 function Catch(...exceptions) {
     return (target) => {
         const metadata = {
@@ -68,10 +13,6 @@ function Catch(...exceptions) {
         Reflect.defineMetadata(exports.CATCH_METADATA, metadata, target);
     };
 }
-/**
- * Get catch metadata from a filter class
- */
 function getCatchMetadata(target) {
     return Reflect.getMetadata(exports.CATCH_METADATA, target);
 }
-//# sourceMappingURL=catch.decorator.js.map

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

@@ -1,21 +1,9 @@
-/**
- * Exception thrown when attempting to register a config provider with a token
- * that is already registered.
- */
 export declare class ConfigProviderAlreadyRegisteredException extends Error {
     constructor(token: string, existingClass: string, newClass: string);
 }
-/**
- * Exception thrown when attempting to retrieve a config provider that
- * has not been registered.
- */
 export declare class ConfigProviderNotFoundException extends Error {
     constructor(token: string, availableTokens?: string[]);
 }
-/**
- * Exception thrown when a config provider fails to instantiate.
- */
 export declare class ConfigProviderInstantiationException extends Error {
     constructor(token: string, className: string, cause: Error);
 }
-//# sourceMappingURL=config.exceptions.d.ts.map

package/dist/core/exceptions/config.exceptions.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigProviderInstantiationException = exports.ConfigProviderNotFoundException = exports.ConfigProviderAlreadyRegisteredException = void 0;
-/**
- * Exception thrown when attempting to register a config provider with a token
- * that is already registered.
- */
 class ConfigProviderAlreadyRegisteredException extends Error {
     constructor(token, existingClass, newClass) {
         super(`Config provider with token "${token}" is already registered.\n` +
@@ -15,10 +11,6 @@ class ConfigProviderAlreadyRegisteredException extends Error {
     }
 }
 exports.ConfigProviderAlreadyRegisteredException = ConfigProviderAlreadyRegisteredException;
-/**
- * Exception thrown when attempting to retrieve a config provider that
- * has not been registered.
- */
 class ConfigProviderNotFoundException extends Error {
     constructor(token, availableTokens = []) {
         const suggestion = availableTokens.length > 0
@@ -33,9 +25,6 @@ class ConfigProviderNotFoundException extends Error {
     }
 }
 exports.ConfigProviderNotFoundException = ConfigProviderNotFoundException;
-/**
- * Exception thrown when a config provider fails to instantiate.
- */
 class ConfigProviderInstantiationException extends Error {
     constructor(token, className, cause) {
         super(`Failed to instantiate config provider "${className}" (token: "${token}").\n` +
@@ -49,4 +38,3 @@ class ConfigProviderInstantiationException extends Error {
     }
 }
 exports.ConfigProviderInstantiationException = ConfigProviderInstantiationException;
-//# sourceMappingURL=config.exceptions.js.map

package/dist/core/exceptions/exception-filter.d.ts

@@ -1,134 +1,38 @@
 import type { FastifyRequest, FastifyReply, FastifyError } from 'fastify';
-/**
- * Exception context passed to filters
- */
 export interface ExceptionContext {
-    /** The caught exception */
     exception: Error;
-    /** Fastify request object */
     request: FastifyRequest;
-    /** Fastify reply object */
     reply: FastifyReply;
-    /** Request path */
     path: string;
-    /** HTTP method */
     method: string;
-    /** Request ID (if available) */
     requestId?: string;
 }
-/**
- * Exception Filter Interface
- *
- * Implement this interface to create custom exception handlers.
- * Filters can catch specific exception types or handle all exceptions.
- *
- * @example
- * ```typescript
- * @Catch(ValidationException)
- * class ValidationExceptionFilter implements ExceptionFilter {
- *   catch(exception: ValidationException, context: ExceptionContext) {
- *     const { reply } = context;
- *     reply.status(422).send({
- *       statusCode: 422,
- *       errors: exception.errors,
- *       timestamp: new Date().toISOString()
- *     });
- *   }
- * }
- * ```
- */
 export interface ExceptionFilter<T extends Error = Error> {
-    /**
-     * Handle the caught exception
-     *
-     * @param exception - The caught exception
-     * @param context - Exception context with request/reply
-     */
     catch(exception: T, context: ExceptionContext): void | Promise<void>;
 }
-/**
- * Standard error response format
- */
 export interface ErrorResponse {
-    /** HTTP status code */
     statusCode: number;
-    /** Error message */
     message: string;
-    /** Error type/name (e.g., "Bad Request", "Not Found") */
     error: string;
-    /** ISO timestamp when the error occurred */
     timestamp: string;
-    /** Request path that caused the error */
     path: string;
-    /** Request ID for tracing (optional) */
     requestId?: string;
-    /** Additional error details (optional) */
     details?: unknown;
-    /** Application-specific error code (optional) */
     code?: string;
-    /** Stack trace (only in development mode) */
     stack?: string;
 }
-/**
- * Global Exception Filter
- *
- * Default exception handler that catches all errors and returns
- * a standardized JSON response.
- *
- * Features:
- * - Handles HttpException with proper status codes
- * - Handles Fastify validation errors
- * - Handles unknown errors as 500 Internal Server Error
- * - Includes stack traces in development mode
- *
- * @example
- * ```typescript
- * // The filter is automatically registered by Rikta
- * // But you can customize behavior via options:
- * const app = await Rikta.create({
- *   exceptionFilter: {
- *     includeStack: process.env.NODE_ENV !== 'production',
- *     logErrors: true
- *   }
- * });
- * ```
- */
 export declare class GlobalExceptionFilter implements ExceptionFilter {
     private readonly includeStack;
     private readonly logErrors;
     constructor(options?: GlobalExceptionFilterOptions);
-    /**
-     * Handle any exception and send standardized response
-     */
     catch(exception: Error, context: ExceptionContext): void;
-    /**
-     * Build standardized error response
-     */
     private buildResponse;
-    /**
-     * Check if error is a Fastify validation error
-     */
     private isFastifyValidationError;
-    /**
-     * Check if error is a Fastify error with statusCode
-     */
     private isFastifyError;
-    /**
-     * Log error to console
-     */
     private logError;
 }
-/**
- * Options for GlobalExceptionFilter
- */
 export interface GlobalExceptionFilterOptions {
-    /** Include stack trace in response (default: true in development) */
     includeStack?: boolean;
-    /** Log errors to console (default: true) */
     logErrors?: boolean;
 }
-/**
- * Create exception handler function for Fastify
- */
 export declare function createExceptionHandler(filter: ExceptionFilter, customFilters?: Map<Function, ExceptionFilter>): (error: FastifyError | Error, request: FastifyRequest, reply: FastifyReply) => Promise<void>;
-//# sourceMappingURL=exception-filter.d.ts.map