@riktajs/core 0.10.1 → 0.10.3

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

@@ -1,18 +0,0 @@
-import 'reflect-metadata';
-import { CONTROLLER_METADATA, INJECTABLE_METADATA } from '../constants.js';
-import { container } from '../container/container.js';
-import { registry } from '../registry.js';
-export function Controller(prefixOrOptions) {
-    return (target) => {
-        const prefix = typeof prefixOrOptions === 'string'
-            ? prefixOrOptions
-            : prefixOrOptions?.prefix ?? '';
-        const normalizedPrefix = prefix
-            ? (prefix.startsWith('/') ? prefix : `/${prefix}`)
-            : '';
-        Reflect.defineMetadata(CONTROLLER_METADATA, { prefix: normalizedPrefix }, target);
-        Reflect.defineMetadata(INJECTABLE_METADATA, { scope: 'singleton' }, target);
-        container.register(target, { scope: 'singleton' });
-        registry.registerController(target);
-    };
-}

package/dist/core/decorators/create-param-decorator.d.ts

@@ -1,11 +0,0 @@
-import 'reflect-metadata';
-import { ExecutionContext } from '../guards/execution-context.js';
-export declare const CUSTOM_PARAM_METADATA: unique symbol;
-export interface CustomParamMetadata<T = unknown> {
-    index: number;
-    factory: CustomParamFactory<T, unknown>;
-    data?: T;
-}
-export type CustomParamFactory<TData = unknown, TResult = unknown> = (data: TData, ctx: ExecutionContext) => TResult | Promise<TResult>;
-export declare function createParamDecorator<TData = unknown, TResult = unknown>(factory: CustomParamFactory<TData, TResult>): (data?: TData) => ParameterDecorator;
-export declare function getCustomParamMetadata<T = unknown>(target: Function, propertyKey: string | symbol): CustomParamMetadata<T>[];

package/dist/core/decorators/create-param-decorator.js

@@ -1,21 +0,0 @@
-import 'reflect-metadata';
-export const CUSTOM_PARAM_METADATA = Symbol.for('rikta:custom:param:metadata');
-export function createParamDecorator(factory) {
-    return (data) => {
-        return (target, propertyKey, parameterIndex) => {
-            if (propertyKey === undefined)
-                return;
-            const existingParams = Reflect.getMetadata(CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
-            const metadata = {
-                index: parameterIndex,
-                factory: factory,
-                data,
-            };
-            existingParams.push(metadata);
-            Reflect.defineMetadata(CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
-        };
-    };
-}
-export function getCustomParamMetadata(target, propertyKey) {
-    return Reflect.getMetadata(CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
-}

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

@@ -1,9 +0,0 @@
-export * from './injectable.decorator.js';
-export * from './controller.decorator.js';
-export * from './route.decorator.js';
-export * from './param.decorator.js';
-export * from './autowired.decorator.js';
-export * from './provider.decorator.js';
-export * from './config-property.decorator.js';
-export * from './create-param-decorator.js';
-export * from './apply-decorators.js';

package/dist/core/decorators/index.js

@@ -1,9 +0,0 @@
-export * from './injectable.decorator.js';
-export * from './controller.decorator.js';
-export * from './route.decorator.js';
-export * from './param.decorator.js';
-export * from './autowired.decorator.js';
-export * from './provider.decorator.js';
-export * from './config-property.decorator.js';
-export * from './create-param-decorator.js';
-export * from './apply-decorators.js';

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

@@ -1,3 +0,0 @@
-import 'reflect-metadata';
-import { InjectableOptions } from '../types.js';
-export declare function Injectable(options?: InjectableOptions): ClassDecorator;

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

@@ -1,11 +0,0 @@
-import 'reflect-metadata';
-import { INJECTABLE_METADATA } from '../constants.js';
-import { container } from '../container/container.js';
-import { registry } from '../registry.js';
-export function Injectable(options = {}) {
-    return (target) => {
-        Reflect.defineMetadata(INJECTABLE_METADATA, options, target);
-        container.register(target, options);
-        registry.registerProvider(target);
-    };
-}

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

@@ -1,59 +0,0 @@
-import 'reflect-metadata';
-import type { ZodType } from 'zod';
-import { ParamType } from '../constants.js';
-export interface ParamMetadata {
-    index: number;
-    type: ParamType;
-    key?: string;
-    zodSchema?: ZodType<unknown>;
-}
-export declare const Body: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Query: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Param: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Headers: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Req: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Request: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Res: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Reply: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Ctx: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};
-export declare const Context: {
-    (): ParameterDecorator;
-    (key: string): ParameterDecorator;
-    <T>(schema: ZodType<T>): ParameterDecorator;
-};

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

@@ -1,38 +0,0 @@
-import 'reflect-metadata';
-import { PARAM_METADATA, ParamType } from '../constants.js';
-function isZodType(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        ('_zod' in value || '_def' in value) &&
-        'safeParse' in value &&
-        typeof value.safeParse === 'function');
-}
-function createParamDecorator(type) {
-    function decorator(keyOrSchema) {
-        return (target, propertyKey, parameterIndex) => {
-            if (propertyKey === undefined)
-                return;
-            const existingParams = Reflect.getMetadata(PARAM_METADATA, target.constructor, propertyKey) ?? [];
-            const isSchema = isZodType(keyOrSchema);
-            const metadata = {
-                index: parameterIndex,
-                type,
-                key: isSchema ? undefined : keyOrSchema,
-                zodSchema: isSchema ? keyOrSchema : undefined,
-            };
-            existingParams.push(metadata);
-            Reflect.defineMetadata(PARAM_METADATA, existingParams, target.constructor, propertyKey);
-        };
-    }
-    return decorator;
-}
-export const Body = createParamDecorator(ParamType.BODY);
-export const Query = createParamDecorator(ParamType.QUERY);
-export const Param = createParamDecorator(ParamType.PARAM);
-export const Headers = createParamDecorator(ParamType.HEADERS);
-export const Req = createParamDecorator(ParamType.REQUEST);
-export const Request = Req;
-export const Res = createParamDecorator(ParamType.REPLY);
-export const Reply = Res;
-export const Ctx = createParamDecorator(ParamType.CONTEXT);
-export const Context = Ctx;

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

@@ -1,12 +0,0 @@
-import 'reflect-metadata';
-import { Token } from '../container/injection-token.js';
-import { Constructor } from '../types.js';
-export interface ProviderMetadata {
-    token: Token;
-}
-export interface ConfigProviderMetadata {
-    token: string;
-}
-export declare function Provider(token?: Token): ClassDecorator;
-export declare function getConfigProviderMetadata(target: Constructor): ConfigProviderMetadata | undefined;
-export declare function isConfigProvider(target: Constructor): boolean;

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

@@ -1,56 +0,0 @@
-import 'reflect-metadata';
-import { PROVIDER_METADATA, CONFIG_PROVIDER_METADATA } from '../constants.js';
-import { registry } from '../registry.js';
-function generateTokenFromClassName(className) {
-    let tokenName = className.replace(/Provider$/, '');
-    tokenName = tokenName
-        .replace(/([A-Z])/g, '_$1')
-        .toUpperCase()
-        .replace(/^_/, '');
-    if (!tokenName.endsWith('_CONFIG') && tokenName !== 'CONFIG') {
-        tokenName = `${tokenName}_CONFIG`;
-    }
-    return tokenName;
-}
-export function Provider(token) {
-    return (target) => {
-        const className = target.name;
-        const isConfigProvider = typeof target.prototype.schema === 'function';
-        if (isConfigProvider) {
-            let configToken;
-            if (typeof token === 'string') {
-                if (token.trim() === '') {
-                    throw new Error(`@Provider: Config provider "${className}" token must be a non-empty string.`);
-                }
-                configToken = token;
-            }
-            else if (token === undefined) {
-                configToken = generateTokenFromClassName(className);
-            }
-            else {
-                throw new Error(`@Provider: Config provider "${className}" requires a string token or no token for auto-generation.`);
-            }
-            if (configToken !== configToken.toUpperCase()) {
-                throw new Error(`@Provider: Token "${configToken}" for config provider "${className}" must be UPPERCASE. ` +
-                    `Use "${configToken.toUpperCase()}" instead.`);
-            }
-            const configMetadata = { token: configToken };
-            Reflect.defineMetadata(CONFIG_PROVIDER_METADATA, configMetadata, target);
-            registry.registerConfigProvider(configToken, target);
-        }
-        else {
-            if (token === undefined) {
-                throw new Error(`@Provider: Custom provider "${className}" requires a token parameter.`);
-            }
-            const metadata = { token };
-            Reflect.defineMetadata(PROVIDER_METADATA, metadata, target);
-            registry.registerCustomProvider(target);
-        }
-    };
-}
-export function getConfigProviderMetadata(target) {
-    return Reflect.getMetadata(CONFIG_PROVIDER_METADATA, target);
-}
-export function isConfigProvider(target) {
-    return Reflect.hasMetadata(CONFIG_PROVIDER_METADATA, target);
-}

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

@@ -1,9 +0,0 @@
-import 'reflect-metadata';
-export declare const Get: (path?: string) => MethodDecorator;
-export declare const Post: (path?: string) => MethodDecorator;
-export declare const Put: (path?: string) => MethodDecorator;
-export declare const Patch: (path?: string) => MethodDecorator;
-export declare const Delete: (path?: string) => MethodDecorator;
-export declare const Options: (path?: string) => MethodDecorator;
-export declare const Head: (path?: string) => MethodDecorator;
-export declare function HttpCode(statusCode: number): MethodDecorator;

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

@@ -1,30 +0,0 @@
-import 'reflect-metadata';
-import { ROUTES_METADATA, HTTP_CODE_METADATA } from '../constants.js';
-function createRouteDecorator(method) {
-    return (path = '') => {
-        return (target, propertyKey, descriptor) => {
-            const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-            const routes = Reflect.getMetadata(ROUTES_METADATA, target.constructor) ?? [];
-            routes.push({
-                method,
-                path: normalizedPath === '/' ? '' : normalizedPath,
-                handlerName: propertyKey,
-            });
-            Reflect.defineMetadata(ROUTES_METADATA, routes, target.constructor);
-            return descriptor;
-        };
-    };
-}
-export const Get = createRouteDecorator('GET');
-export const Post = createRouteDecorator('POST');
-export const Put = createRouteDecorator('PUT');
-export const Patch = createRouteDecorator('PATCH');
-export const Delete = createRouteDecorator('DELETE');
-export const Options = createRouteDecorator('OPTIONS');
-export const Head = createRouteDecorator('HEAD');
-export function HttpCode(statusCode) {
-    return (target, propertyKey, descriptor) => {
-        Reflect.defineMetadata(HTTP_CODE_METADATA, statusCode, target.constructor, propertyKey);
-        return descriptor;
-    };
-}

package/dist/core/discovery.d.ts

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

package/dist/core/discovery.js

@@ -1,111 +0,0 @@
-import fg from 'fast-glob';
-import fs from 'fs/promises';
-import path from 'path';
-import { DiscoveryException } from './exceptions/discovery.exception.js';
-const DEFAULT_IGNORE_PATTERNS = [
-    '**/node_modules/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/benchmarks/**',
-    '**/*.test.ts',
-    '**/*.spec.ts',
-    '**/*.d.ts',
-];
-function getEntryPointDirectory() {
-    const mainScript = process.argv[1];
-    if (mainScript) {
-        const filePath = mainScript.startsWith('file://')
-            ? new URL(mainScript).pathname
-            : mainScript;
-        return path.dirname(filePath);
-    }
-    return process.cwd();
-}
-const DECORATOR_PATTERNS = [
-    /@Controller\s*\(/,
-    /@Injectable\s*\(/,
-    /@Provider\s*\(/,
-    /\.\s*Controller\s*\)\s*\(/,
-    /\.\s*Injectable\s*\)\s*\(/,
-    /\.\s*Provider\s*\)\s*\(/,
-    /\.\s*ProviderConfig\s*\)\s*\(/,
-    /import\s*{\s*[^}]*\bController\b[^}]*}\s*from\s*['"]@riktajs\/core['"]/,
-    /import\s*{\s*[^}]*\bInjectable\b[^}]*}\s*from\s*['"]@riktajs\/core['"]/,
-    /import\s*{\s*[^}]*\bProvider\b[^}]*}\s*from\s*['"]@riktajs\/core['"]/,
-];
-async function containsRiktaDecorators(filePath) {
-    try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        return DECORATOR_PATTERNS.some(pattern => pattern.test(content));
-    }
-    catch {
-        return false;
-    }
-}
-export async function discoverModules(optionsOrPatterns = ['./**/*.{ts,js}'], cwd) {
-    const options = Array.isArray(optionsOrPatterns)
-        ? { patterns: optionsOrPatterns, cwd }
-        : optionsOrPatterns;
-    const patterns = options.patterns ?? ['./**/*.{ts,js}'];
-    const strict = options.strict ?? false;
-    const onImportError = options.onImportError;
-    const baseDir = options.cwd ?? cwd ?? getEntryPointDirectory();
-    const absoluteBaseDir = path.isAbsolute(baseDir)
-        ? baseDir
-        : path.resolve(process.cwd(), baseDir);
-    const normalizedPatterns = patterns.map(pattern => {
-        let normalizedPattern = pattern;
-        if (path.isAbsolute(pattern)) {
-            normalizedPattern = path.relative(absoluteBaseDir, pattern);
-            if (!normalizedPattern.startsWith('.')) {
-                normalizedPattern = './' + normalizedPattern;
-            }
-        }
-        if (/\.\w+$/.test(normalizedPattern) || normalizedPattern.endsWith('*')) {
-            return normalizedPattern;
-        }
-        return normalizedPattern.endsWith('/')
-            ? `${normalizedPattern}**/*.{ts,js}`
-            : `${normalizedPattern}/**/*.{ts,js}`;
-    });
-    const files = await fg(normalizedPatterns, {
-        cwd: absoluteBaseDir,
-        absolute: true,
-        ignore: DEFAULT_IGNORE_PATTERNS,
-        onlyFiles: true,
-    });
-    const decoratorChecks = await Promise.all(files.map(async (file) => ({ file, hasDecorators: await containsRiktaDecorators(file) })));
-    const riktaFiles = decoratorChecks
-        .filter(({ hasDecorators }) => hasDecorators)
-        .map(({ file }) => file);
-    const importedFiles = [];
-    const failedImports = [];
-    for (const file of riktaFiles) {
-        try {
-            let importPath;
-            if (file.endsWith('.js')) {
-                importPath = `file://${file}`;
-            }
-            else {
-                importPath = file.replace(/\.ts$/, '');
-            }
-            await import(importPath);
-            importedFiles.push(file);
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            onImportError?.(file, error);
-            if (process.env.DEBUG) {
-                console.warn(`[Rikta] Failed to import ${file}:`, error.message);
-            }
-            failedImports.push({ filePath: file, error });
-        }
-    }
-    if (strict && failedImports.length > 0) {
-        throw new DiscoveryException(failedImports);
-    }
-    return importedFiles;
-}
-export function getCallerDirectory() {
-    return getEntryPointDirectory();
-}

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

@@ -1,8 +0,0 @@
-import 'reflect-metadata';
-import { Constructor } from '../types.js';
-export declare const CATCH_METADATA: unique symbol;
-export interface CatchMetadata {
-    exceptions: Constructor<Error>[];
-}
-export declare function Catch(...exceptions: Constructor<Error>[]): ClassDecorator;
-export declare function getCatchMetadata(target: Constructor): CatchMetadata | undefined;

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

@@ -1,13 +0,0 @@
-import 'reflect-metadata';
-export const CATCH_METADATA = Symbol('catch:metadata');
-export function Catch(...exceptions) {
-    return (target) => {
-        const metadata = {
-            exceptions: exceptions.length > 0 ? exceptions : [],
-        };
-        Reflect.defineMetadata(CATCH_METADATA, metadata, target);
-    };
-}
-export function getCatchMetadata(target) {
-    return Reflect.getMetadata(CATCH_METADATA, target);
-}

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

@@ -1,9 +0,0 @@
-export declare class ConfigProviderAlreadyRegisteredException extends Error {
-    constructor(token: string, existingClass: string, newClass: string);
-}
-export declare class ConfigProviderNotFoundException extends Error {
-    constructor(token: string, availableTokens?: string[]);
-}
-export declare class ConfigProviderInstantiationException extends Error {
-    constructor(token: string, className: string, cause: Error);
-}

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

@@ -1,34 +0,0 @@
-export class ConfigProviderAlreadyRegisteredException extends Error {
-    constructor(token, existingClass, newClass) {
-        super(`Config provider with token "${token}" is already registered.\n` +
-            `Existing: ${existingClass}\n` +
-            `Attempted: ${newClass}\n` +
-            `Use a different token or remove the duplicate registration.`);
-        this.name = 'ConfigProviderAlreadyRegisteredException';
-    }
-}
-export class ConfigProviderNotFoundException extends Error {
-    constructor(token, availableTokens = []) {
-        const suggestion = availableTokens.length > 0
-            ? `\n\nAvailable tokens: ${availableTokens.join(', ')}`
-            : '';
-        super(`Config provider with token "${token}" not found.${suggestion}\n` +
-            `Make sure the provider class is:\n` +
-            `1. Decorated with @Provider('${token}')\n` +
-            `2. Located in a file matching the autowired patterns\n` +
-            `3. Properly exported from its module`);
-        this.name = 'ConfigProviderNotFoundException';
-    }
-}
-export class ConfigProviderInstantiationException extends Error {
-    constructor(token, className, cause) {
-        super(`Failed to instantiate config provider "${className}" (token: "${token}").\n` +
-            `Cause: ${cause.message}\n\n` +
-            `Check that the provider:\n` +
-            `1. Has a valid constructor\n` +
-            `2. All constructor dependencies are registered\n` +
-            `3. The provide() method is correctly implemented`);
-        this.name = 'ConfigProviderInstantiationException';
-        this.cause = cause;
-    }
-}

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

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

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

@@ -1,39 +0,0 @@
-export 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');
-    }
-}

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

@@ -1,38 +0,0 @@
-import type { FastifyRequest, FastifyReply, FastifyError } from 'fastify';
-export interface ExceptionContext {
-    exception: Error;
-    request: FastifyRequest;
-    reply: FastifyReply;
-    path: string;
-    method: string;
-    requestId?: string;
-}
-export interface ExceptionFilter<T extends Error = Error> {
-    catch(exception: T, context: ExceptionContext): void | Promise<void>;
-}
-export interface ErrorResponse {
-    statusCode: number;
-    message: string;
-    error: string;
-    timestamp: string;
-    path: string;
-    requestId?: string;
-    details?: unknown;
-    code?: string;
-    stack?: string;
-}
-export declare class GlobalExceptionFilter implements ExceptionFilter {
-    private readonly includeStack;
-    private readonly logErrors;
-    constructor(options?: GlobalExceptionFilterOptions);
-    catch(exception: Error, context: ExceptionContext): void;
-    private buildResponse;
-    private isFastifyValidationError;
-    private isFastifyError;
-    private logError;
-}
-export interface GlobalExceptionFilterOptions {
-    includeStack?: boolean;
-    logErrors?: boolean;
-}
-export declare function createExceptionHandler(filter: ExceptionFilter, customFilters?: Map<Function, ExceptionFilter>): (error: FastifyError | Error, request: FastifyRequest, reply: FastifyReply) => Promise<void>;