@riktajs/core 0.8.0 → 0.10.0

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.Ctx = exports.Reply = exports.Res = exports.Request = exports.Req = exports.Headers = exports.Param = exports.Query = exports.Body = void 0;
-require("reflect-metadata");
-const constants_1 = require("../constants");
+import 'reflect-metadata';
+import { PARAM_METADATA, ParamType } from '../constants.js';
 function isZodType(value) {
     return (value !== null &&
         typeof value === 'object' &&
@@ -15,7 +12,7 @@ function createParamDecorator(type) {
         return (target, propertyKey, parameterIndex) => {
             if (propertyKey === undefined)
                 return;
-            const existingParams = Reflect.getMetadata(constants_1.PARAM_METADATA, target.constructor, propertyKey) ?? [];
+            const existingParams = Reflect.getMetadata(PARAM_METADATA, target.constructor, propertyKey) ?? [];
             const isSchema = isZodType(keyOrSchema);
             const metadata = {
                 index: parameterIndex,
@@ -24,18 +21,18 @@ function createParamDecorator(type) {
                 zodSchema: isSchema ? keyOrSchema : undefined,
             };
             existingParams.push(metadata);
-            Reflect.defineMetadata(constants_1.PARAM_METADATA, existingParams, target.constructor, propertyKey);
+            Reflect.defineMetadata(PARAM_METADATA, existingParams, target.constructor, propertyKey);
         };
     }
     return decorator;
 }
-exports.Body = createParamDecorator(constants_1.ParamType.BODY);
-exports.Query = createParamDecorator(constants_1.ParamType.QUERY);
-exports.Param = createParamDecorator(constants_1.ParamType.PARAM);
-exports.Headers = createParamDecorator(constants_1.ParamType.HEADERS);
-exports.Req = createParamDecorator(constants_1.ParamType.REQUEST);
-exports.Request = exports.Req;
-exports.Res = createParamDecorator(constants_1.ParamType.REPLY);
-exports.Reply = exports.Res;
-exports.Ctx = createParamDecorator(constants_1.ParamType.CONTEXT);
-exports.Context = exports.Ctx;
+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,6 +1,6 @@
 import 'reflect-metadata';
-import { Token } from '../container/injection-token';
-import { Constructor } from '../types';
+import { Token } from '../container/injection-token.js';
+import { Constructor } from '../types.js';
 export interface ProviderMetadata {
     token: Token;
 }

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

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Provider = Provider;
-exports.getConfigProviderMetadata = getConfigProviderMetadata;
-exports.isConfigProvider = isConfigProvider;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const registry_1 = require("../registry");
+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
@@ -17,7 +12,7 @@ function generateTokenFromClassName(className) {
     }
     return tokenName;
 }
-function Provider(token) {
+export function Provider(token) {
     return (target) => {
         const className = target.name;
         const isConfigProvider = typeof target.prototype.schema === 'function';
@@ -40,22 +35,22 @@ function Provider(token) {
                     `Use "${configToken.toUpperCase()}" instead.`);
             }
             const configMetadata = { token: configToken };
-            Reflect.defineMetadata(constants_1.CONFIG_PROVIDER_METADATA, configMetadata, target);
-            registry_1.registry.registerConfigProvider(configToken, target);
+            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(constants_1.PROVIDER_METADATA, metadata, target);
-            registry_1.registry.registerCustomProvider(target);
+            Reflect.defineMetadata(PROVIDER_METADATA, metadata, target);
+            registry.registerCustomProvider(target);
         }
     };
 }
-function getConfigProviderMetadata(target) {
-    return Reflect.getMetadata(constants_1.CONFIG_PROVIDER_METADATA, target);
+export function getConfigProviderMetadata(target) {
+    return Reflect.getMetadata(CONFIG_PROVIDER_METADATA, target);
 }
-function isConfigProvider(target) {
-    return Reflect.hasMetadata(constants_1.CONFIG_PROVIDER_METADATA, target);
+export function isConfigProvider(target) {
+    return Reflect.hasMetadata(CONFIG_PROVIDER_METADATA, target);
 }

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

@@ -1,34 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Head = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = void 0;
-exports.HttpCode = HttpCode;
-require("reflect-metadata");
-const constants_1 = require("../constants");
+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(constants_1.ROUTES_METADATA, target.constructor) ?? [];
+            const routes = Reflect.getMetadata(ROUTES_METADATA, target.constructor) ?? [];
             routes.push({
                 method,
                 path: normalizedPath === '/' ? '' : normalizedPath,
                 handlerName: propertyKey,
             });
-            Reflect.defineMetadata(constants_1.ROUTES_METADATA, routes, target.constructor);
+            Reflect.defineMetadata(ROUTES_METADATA, routes, target.constructor);
             return descriptor;
         };
     };
 }
-exports.Get = createRouteDecorator('GET');
-exports.Post = createRouteDecorator('POST');
-exports.Put = createRouteDecorator('PUT');
-exports.Patch = createRouteDecorator('PATCH');
-exports.Delete = createRouteDecorator('DELETE');
-exports.Options = createRouteDecorator('OPTIONS');
-exports.Head = createRouteDecorator('HEAD');
-function HttpCode(statusCode) {
+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(constants_1.HTTP_CODE_METADATA, statusCode, target.constructor, propertyKey);
+        Reflect.defineMetadata(HTTP_CODE_METADATA, statusCode, target.constructor, propertyKey);
         return descriptor;
     };
 }

package/dist/core/discovery.d.ts

@@ -1,2 +1,3 @@
-export declare function discoverModules(patterns?: string[], cwd?: string): Promise<string[]>;
+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,46 +1,7 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.discoverModules = discoverModules;
-exports.getCallerDirectory = getCallerDirectory;
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
+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/**',
@@ -56,7 +17,7 @@ function getEntryPointDirectory() {
         const filePath = mainScript.startsWith('file://')
             ? new URL(mainScript).pathname
             : mainScript;
-        return path_1.default.dirname(filePath);
+        return path.dirname(filePath);
     }
     return process.cwd();
 }
@@ -64,30 +25,38 @@ const DECORATOR_PATTERNS = [
     /@Controller\s*\(/,
     /@Injectable\s*\(/,
     /@Provider\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 promises_1.default.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, 'utf-8');
         return DECORATOR_PATTERNS.some(pattern => pattern.test(content));
     }
     catch {
         return false;
     }
 }
-async function discoverModules(patterns = ['./**/*.{ts,js}'], cwd) {
-    const baseDir = cwd ?? getEntryPointDirectory();
-    const absoluteBaseDir = path_1.default.isAbsolute(baseDir)
+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_1.default.resolve(process.cwd(), baseDir);
+        : path.resolve(process.cwd(), baseDir);
     const normalizedPatterns = patterns.map(pattern => {
         let normalizedPattern = pattern;
-        if (path_1.default.isAbsolute(pattern)) {
-            normalizedPattern = path_1.default.relative(absoluteBaseDir, pattern);
+        if (path.isAbsolute(pattern)) {
+            normalizedPattern = path.relative(absoluteBaseDir, pattern);
             if (!normalizedPattern.startsWith('.')) {
                 normalizedPattern = './' + normalizedPattern;
             }
@@ -99,33 +68,44 @@ async function discoverModules(patterns = ['./**/*.{ts,js}'], cwd) {
             ? `${normalizedPattern}**/*.{ts,js}`
             : `${normalizedPattern}/**/*.{ts,js}`;
     });
-    const files = await (0, fast_glob_1.default)(normalizedPatterns, {
+    const files = await fg(normalizedPatterns, {
         cwd: absoluteBaseDir,
         absolute: true,
         ignore: DEFAULT_IGNORE_PATTERNS,
         onlyFiles: true,
     });
-    const riktaFiles = [];
-    for (const file of files) {
-        if (await containsRiktaDecorators(file)) {
-            riktaFiles.push(file);
-        }
-    }
+    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 {
-            const importPath = file.replace(/\.ts$/, '');
-            await Promise.resolve(`${importPath}`).then(s => __importStar(require(s)));
+            let importPath;
+            if (file.endsWith('.js')) {
+                importPath = `file://${file}`;
+            }
+            else {
+                importPath = file.replace(/\.ts$/, '');
+            }
+            await import(importPath);
             importedFiles.push(file);
         }
-        catch (error) {
+        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);
+                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;
 }
-function getCallerDirectory() {
+export function getCallerDirectory() {
     return getEntryPointDirectory();
 }

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

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Constructor } from '../types';
+import { Constructor } from '../types.js';
 export declare const CATCH_METADATA: unique symbol;
 export interface CatchMetadata {
     exceptions: Constructor<Error>[];

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

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CATCH_METADATA = void 0;
-exports.Catch = Catch;
-exports.getCatchMetadata = getCatchMetadata;
-require("reflect-metadata");
-exports.CATCH_METADATA = Symbol('catch:metadata');
-function Catch(...exceptions) {
+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(exports.CATCH_METADATA, metadata, target);
+        Reflect.defineMetadata(CATCH_METADATA, metadata, target);
     };
 }
-function getCatchMetadata(target) {
-    return Reflect.getMetadata(exports.CATCH_METADATA, target);
+export function getCatchMetadata(target) {
+    return Reflect.getMetadata(CATCH_METADATA, target);
 }

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

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigProviderInstantiationException = exports.ConfigProviderNotFoundException = exports.ConfigProviderAlreadyRegisteredException = void 0;
-class ConfigProviderAlreadyRegisteredException extends Error {
+export class ConfigProviderAlreadyRegisteredException extends Error {
     constructor(token, existingClass, newClass) {
         super(`Config provider with token "${token}" is already registered.\n` +
             `Existing: ${existingClass}\n` +
@@ -10,8 +7,7 @@ class ConfigProviderAlreadyRegisteredException extends Error {
         this.name = 'ConfigProviderAlreadyRegisteredException';
     }
 }
-exports.ConfigProviderAlreadyRegisteredException = ConfigProviderAlreadyRegisteredException;
-class ConfigProviderNotFoundException extends Error {
+export class ConfigProviderNotFoundException extends Error {
     constructor(token, availableTokens = []) {
         const suggestion = availableTokens.length > 0
             ? `\n\nAvailable tokens: ${availableTokens.join(', ')}`
@@ -24,8 +20,7 @@ class ConfigProviderNotFoundException extends Error {
         this.name = 'ConfigProviderNotFoundException';
     }
 }
-exports.ConfigProviderNotFoundException = ConfigProviderNotFoundException;
-class ConfigProviderInstantiationException extends Error {
+export class ConfigProviderInstantiationException extends Error {
     constructor(token, className, cause) {
         super(`Failed to instantiate config provider "${className}" (token: "${token}").\n` +
             `Cause: ${cause.message}\n\n` +
@@ -37,4 +32,3 @@ class ConfigProviderInstantiationException extends Error {
         this.cause = cause;
     }
 }
-exports.ConfigProviderInstantiationException = ConfigProviderInstantiationException;

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,39 @@
+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.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalExceptionFilter = void 0;
-exports.createExceptionHandler = createExceptionHandler;
-const http_exception_1 = require("./http-exception");
-class GlobalExceptionFilter {
+import { HttpException } from './http-exception.js';
+export class GlobalExceptionFilter {
     includeStack;
     logErrors;
     constructor(options = {}) {
@@ -20,7 +16,7 @@ class GlobalExceptionFilter {
         reply.status(response.statusCode).send(response);
     }
     buildResponse(exception, path, requestId) {
-        if (exception instanceof http_exception_1.HttpException) {
+        if (exception instanceof HttpException) {
             const httpResponse = exception.getResponse();
             return {
                 statusCode: httpResponse.statusCode,
@@ -76,7 +72,7 @@ class GlobalExceptionFilter {
     }
     logError(exception, method, path, requestId) {
         const timestamp = new Date().toISOString();
-        const status = exception instanceof http_exception_1.HttpException
+        const status = exception instanceof HttpException
             ? exception.getStatus()
             : 500;
         const prefix = status >= 500 ? '❌' : '⚠️';
@@ -87,8 +83,7 @@ class GlobalExceptionFilter {
         }
     }
 }
-exports.GlobalExceptionFilter = GlobalExceptionFilter;
-function createExceptionHandler(filter, customFilters = new Map()) {
+export function createExceptionHandler(filter, customFilters = new Map()) {
     return async (error, request, reply) => {
         const context = {
             exception: error,

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

@@ -1,4 +1,4 @@
-import { HttpException, HttpExceptionBody } from './http-exception';
+import { HttpException, HttpExceptionBody } from './http-exception.js';
 export declare class BadRequestException extends HttpException {
     constructor(response?: string | HttpExceptionBody);
 }

package/dist/core/exceptions/exceptions.js

@@ -1,112 +1,91 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayTimeoutException = exports.ServiceUnavailableException = exports.BadGatewayException = exports.NotImplementedException = exports.InternalServerErrorException = exports.TooManyRequestsException = exports.UnprocessableEntityException = exports.UnsupportedMediaTypeException = exports.PayloadTooLargeException = exports.GoneException = exports.ConflictException = exports.RequestTimeoutException = exports.NotAcceptableException = exports.MethodNotAllowedException = exports.NotFoundException = exports.ForbiddenException = exports.UnauthorizedException = exports.BadRequestException = void 0;
-const http_exception_1 = require("./http-exception");
-class BadRequestException extends http_exception_1.HttpException {
+import { HttpException } from './http-exception.js';
+export class BadRequestException extends HttpException {
     constructor(response = 'Bad Request') {
         super(response, 400);
     }
 }
-exports.BadRequestException = BadRequestException;
-class UnauthorizedException extends http_exception_1.HttpException {
+export class UnauthorizedException extends HttpException {
     constructor(response = 'Unauthorized') {
         super(response, 401);
     }
 }
-exports.UnauthorizedException = UnauthorizedException;
-class ForbiddenException extends http_exception_1.HttpException {
+export class ForbiddenException extends HttpException {
     constructor(response = 'Forbidden') {
         super(response, 403);
     }
 }
-exports.ForbiddenException = ForbiddenException;
-class NotFoundException extends http_exception_1.HttpException {
+export class NotFoundException extends HttpException {
     constructor(response = 'Not Found') {
         super(response, 404);
     }
 }
-exports.NotFoundException = NotFoundException;
-class MethodNotAllowedException extends http_exception_1.HttpException {
+export class MethodNotAllowedException extends HttpException {
     constructor(response = 'Method Not Allowed') {
         super(response, 405);
     }
 }
-exports.MethodNotAllowedException = MethodNotAllowedException;
-class NotAcceptableException extends http_exception_1.HttpException {
+export class NotAcceptableException extends HttpException {
     constructor(response = 'Not Acceptable') {
         super(response, 406);
     }
 }
-exports.NotAcceptableException = NotAcceptableException;
-class RequestTimeoutException extends http_exception_1.HttpException {
+export class RequestTimeoutException extends HttpException {
     constructor(response = 'Request Timeout') {
         super(response, 408);
     }
 }
-exports.RequestTimeoutException = RequestTimeoutException;
-class ConflictException extends http_exception_1.HttpException {
+export class ConflictException extends HttpException {
     constructor(response = 'Conflict') {
         super(response, 409);
     }
 }
-exports.ConflictException = ConflictException;
-class GoneException extends http_exception_1.HttpException {
+export class GoneException extends HttpException {
     constructor(response = 'Gone') {
         super(response, 410);
     }
 }
-exports.GoneException = GoneException;
-class PayloadTooLargeException extends http_exception_1.HttpException {
+export class PayloadTooLargeException extends HttpException {
     constructor(response = 'Payload Too Large') {
         super(response, 413);
     }
 }
-exports.PayloadTooLargeException = PayloadTooLargeException;
-class UnsupportedMediaTypeException extends http_exception_1.HttpException {
+export class UnsupportedMediaTypeException extends HttpException {
     constructor(response = 'Unsupported Media Type') {
         super(response, 415);
     }
 }
-exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;
-class UnprocessableEntityException extends http_exception_1.HttpException {
+export class UnprocessableEntityException extends HttpException {
     constructor(response = 'Unprocessable Entity') {
         super(response, 422);
     }
 }
-exports.UnprocessableEntityException = UnprocessableEntityException;
-class TooManyRequestsException extends http_exception_1.HttpException {
+export class TooManyRequestsException extends HttpException {
     constructor(response = 'Too Many Requests') {
         super(response, 429);
     }
 }
-exports.TooManyRequestsException = TooManyRequestsException;
-class InternalServerErrorException extends http_exception_1.HttpException {
+export class InternalServerErrorException extends HttpException {
     constructor(response = 'Internal Server Error') {
         super(response, 500);
     }
 }
-exports.InternalServerErrorException = InternalServerErrorException;
-class NotImplementedException extends http_exception_1.HttpException {
+export class NotImplementedException extends HttpException {
     constructor(response = 'Not Implemented') {
         super(response, 501);
     }
 }
-exports.NotImplementedException = NotImplementedException;
-class BadGatewayException extends http_exception_1.HttpException {
+export class BadGatewayException extends HttpException {
     constructor(response = 'Bad Gateway') {
         super(response, 502);
     }
 }
-exports.BadGatewayException = BadGatewayException;
-class ServiceUnavailableException extends http_exception_1.HttpException {
+export class ServiceUnavailableException extends HttpException {
     constructor(response = 'Service Unavailable') {
         super(response, 503);
     }
 }
-exports.ServiceUnavailableException = ServiceUnavailableException;
-class GatewayTimeoutException extends http_exception_1.HttpException {
+export class GatewayTimeoutException extends HttpException {
     constructor(response = 'Gateway Timeout') {
         super(response, 504);
     }
 }
-exports.GatewayTimeoutException = GatewayTimeoutException;

package/dist/core/exceptions/http-exception.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpException = void 0;
-class HttpException extends Error {
+export class HttpException extends Error {
     statusCode;
     response;
     timestamp;
@@ -63,4 +60,3 @@ class HttpException extends Error {
         return errors[statusCode] ?? 'Error';
     }
 }
-exports.HttpException = HttpException;