@velajs/vela 0.5.0 → 0.5.2

package/dist/constants.d.ts

@@ -20,7 +20,8 @@ export declare enum HttpMethod {
     PATCH = "patch",
     DELETE = "delete",
     OPTIONS = "options",
-    HEAD = "head"
+    HEAD = "head",
+    ALL = "all"
 }
 export declare enum ParamType {
     BODY = "body",

package/dist/constants.js

@@ -26,6 +26,7 @@ export var HttpMethod = /*#__PURE__*/ function(HttpMethod) {
     HttpMethod["DELETE"] = "delete";
     HttpMethod["OPTIONS"] = "options";
     HttpMethod["HEAD"] = "head";
+    HttpMethod["ALL"] = "all";
     return HttpMethod;
 }({});
 export var ParamType = /*#__PURE__*/ function(ParamType) {

package/dist/container/container.js

@@ -172,7 +172,10 @@ export class Container {
         if (!registration.useFactory) {
             throw new Error('Factory function is missing');
         }
-        const dependencies = (registration.inject || []).map((token)=>this.resolve(token));
+        const dependencies = (registration.inject || []).map((token)=>{
+            const resolved = token instanceof ForwardRef ? token.factory() : token;
+            return this.resolve(resolved);
+        });
         const result = registration.useFactory(...dependencies);
         if (result instanceof Promise) {
             throw new Error(`Async factory for ${this.tokenToString(registration.provide)} returned a Promise. ` + `Use resolveAsync() for async providers.`);

package/dist/errors/http-exception.d.ts

@@ -1,61 +1,61 @@
 export declare class HttpException extends Error {
     readonly statusCode: number;
-    readonly response?: unknown | undefined;
-    constructor(message: string, statusCode: number, response?: unknown | undefined);
+    private readonly _response;
+    constructor(response: string | object, statusCode: number);
     getStatus(): number;
     getResponse(): unknown;
 }
 export declare class BadRequestException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class UnauthorizedException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class ForbiddenException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class NotFoundException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class MethodNotAllowedException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class NotAcceptableException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class RequestTimeoutException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class ConflictException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class GoneException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class PayloadTooLargeException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class UnsupportedMediaTypeException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class UnprocessableEntityException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class TooManyRequestsException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class InternalServerErrorException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class NotImplementedException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class BadGatewayException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class ServiceUnavailableException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }
 export declare class GatewayTimeoutException extends HttpException {
-    constructor(message?: string, response?: unknown);
+    constructor(message?: string | object);
 }

package/dist/errors/http-exception.js

@@ -1,128 +1,134 @@
 export class HttpException extends Error {
     statusCode;
-    response;
-    constructor(message, statusCode, response){
-        super(message), this.statusCode = statusCode, this.response = response;
+    _response;
+    constructor(response, statusCode){
+        const message = typeof response === 'string' ? response : JSON.stringify(response);
+        super(message);
         this.name = 'HttpException';
+        this.statusCode = statusCode;
+        this._response = response;
         Object.setPrototypeOf(this, new.target.prototype);
     }
     getStatus() {
         return this.statusCode;
     }
     getResponse() {
-        return this.response ?? {
+        if (typeof this._response === 'object' && this._response !== null) {
+            return this._response;
+        }
+        return {
             statusCode: this.statusCode,
-            message: this.message
+            message: this._response
         };
     }
 }
 // 4xx
 export class BadRequestException extends HttpException {
-    constructor(message = 'Bad Request', response){
-        super(message, 400, response);
+    constructor(message = 'Bad Request'){
+        super(message, 400);
         this.name = 'BadRequestException';
     }
 }
 export class UnauthorizedException extends HttpException {
-    constructor(message = 'Unauthorized', response){
-        super(message, 401, response);
+    constructor(message = 'Unauthorized'){
+        super(message, 401);
         this.name = 'UnauthorizedException';
     }
 }
 export class ForbiddenException extends HttpException {
-    constructor(message = 'Forbidden', response){
-        super(message, 403, response);
+    constructor(message = 'Forbidden'){
+        super(message, 403);
         this.name = 'ForbiddenException';
     }
 }
 export class NotFoundException extends HttpException {
-    constructor(message = 'Not Found', response){
-        super(message, 404, response);
+    constructor(message = 'Not Found'){
+        super(message, 404);
         this.name = 'NotFoundException';
     }
 }
 export class MethodNotAllowedException extends HttpException {
-    constructor(message = 'Method Not Allowed', response){
-        super(message, 405, response);
+    constructor(message = 'Method Not Allowed'){
+        super(message, 405);
         this.name = 'MethodNotAllowedException';
     }
 }
 export class NotAcceptableException extends HttpException {
-    constructor(message = 'Not Acceptable', response){
-        super(message, 406, response);
+    constructor(message = 'Not Acceptable'){
+        super(message, 406);
         this.name = 'NotAcceptableException';
     }
 }
 export class RequestTimeoutException extends HttpException {
-    constructor(message = 'Request Timeout', response){
-        super(message, 408, response);
+    constructor(message = 'Request Timeout'){
+        super(message, 408);
         this.name = 'RequestTimeoutException';
     }
 }
 export class ConflictException extends HttpException {
-    constructor(message = 'Conflict', response){
-        super(message, 409, response);
+    constructor(message = 'Conflict'){
+        super(message, 409);
         this.name = 'ConflictException';
     }
 }
 export class GoneException extends HttpException {
-    constructor(message = 'Gone', response){
-        super(message, 410, response);
+    constructor(message = 'Gone'){
+        super(message, 410);
         this.name = 'GoneException';
     }
 }
 export class PayloadTooLargeException extends HttpException {
-    constructor(message = 'Payload Too Large', response){
-        super(message, 413, response);
+    constructor(message = 'Payload Too Large'){
+        super(message, 413);
         this.name = 'PayloadTooLargeException';
     }
 }
 export class UnsupportedMediaTypeException extends HttpException {
-    constructor(message = 'Unsupported Media Type', response){
-        super(message, 415, response);
+    constructor(message = 'Unsupported Media Type'){
+        super(message, 415);
         this.name = 'UnsupportedMediaTypeException';
     }
 }
 export class UnprocessableEntityException extends HttpException {
-    constructor(message = 'Unprocessable Entity', response){
-        super(message, 422, response);
+    constructor(message = 'Unprocessable Entity'){
+        super(message, 422);
         this.name = 'UnprocessableEntityException';
     }
 }
 export class TooManyRequestsException extends HttpException {
-    constructor(message = 'Too Many Requests', response){
-        super(message, 429, response);
+    constructor(message = 'Too Many Requests'){
+        super(message, 429);
         this.name = 'TooManyRequestsException';
     }
 }
 // 5xx
 export class InternalServerErrorException extends HttpException {
-    constructor(message = 'Internal Server Error', response){
-        super(message, 500, response);
+    constructor(message = 'Internal Server Error'){
+        super(message, 500);
         this.name = 'InternalServerErrorException';
     }
 }
 export class NotImplementedException extends HttpException {
-    constructor(message = 'Not Implemented', response){
-        super(message, 501, response);
+    constructor(message = 'Not Implemented'){
+        super(message, 501);
         this.name = 'NotImplementedException';
     }
 }
 export class BadGatewayException extends HttpException {
-    constructor(message = 'Bad Gateway', response){
-        super(message, 502, response);
+    constructor(message = 'Bad Gateway'){
+        super(message, 502);
         this.name = 'BadGatewayException';
     }
 }
 export class ServiceUnavailableException extends HttpException {
-    constructor(message = 'Service Unavailable', response){
-        super(message, 503, response);
+    constructor(message = 'Service Unavailable'){
+        super(message, 503);
         this.name = 'ServiceUnavailableException';
     }
 }
 export class GatewayTimeoutException extends HttpException {
-    constructor(message = 'Gateway Timeout', response){
-        super(message, 504, response);
+    constructor(message = 'Gateway Timeout'){
+        super(message, 504);
         this.name = 'GatewayTimeoutException';
     }
 }

package/dist/health/health.service.js

@@ -19,7 +19,7 @@ export class HealthCheckService {
                 error: {},
                 details: {}
             };
-            throw new ServiceUnavailableException('Service Unavailable', result);
+            throw new ServiceUnavailableException(result);
         }
         const results = await Promise.allSettled(indicators.map((fn)=>fn()));
         const info = {};
@@ -55,7 +55,7 @@ export class HealthCheckService {
             details
         };
         if (status === 'error') {
-            throw new ServiceUnavailableException('Service Unavailable', checkResult);
+            throw new ServiceUnavailableException(checkResult);
         }
         return checkResult;
     }

package/dist/http/decorators.d.ts

@@ -38,6 +38,7 @@ 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 const All: (path?: string) => MethodDecorator;
 export declare const Sse: (path?: string) => MethodDecorator;
 export declare const Param: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;

package/dist/http/decorators.js

@@ -22,7 +22,7 @@ function normalizePath(path) {
         if (typeof prefixOrOptions === 'string') {
             prefix = prefixOrOptions;
         } else if (prefixOrOptions) {
-            prefix = prefixOrOptions.prefix ?? '';
+            prefix = prefixOrOptions.path ?? prefixOrOptions.prefix ?? '';
             version = prefixOrOptions.version;
         } else {
             prefix = '';
@@ -96,6 +96,7 @@ export const Patch = createMethodDecorator(HttpMethod.PATCH);
 export const Delete = createMethodDecorator(HttpMethod.DELETE);
 export const Options = createMethodDecorator(HttpMethod.OPTIONS);
 export const Head = createMethodDecorator(HttpMethod.HEAD);
+export const All = createMethodDecorator(HttpMethod.ALL);
 export const Sse = createMethodDecorator(HttpMethod.GET);
 // Parameter decorators
 const CUSTOM_PARAM_TYPE = 'custom';

package/dist/http/index.d.ts

@@ -1,5 +1,5 @@
 export { RouteManager } from './route.manager';
 export { MiddlewareBuilder, RequestMethod } from './middleware-consumer';
 export type { MiddlewareConsumer, MiddlewareConfigProxy, RouteInfo, NestModule, MiddlewareRouteDefinition } from './middleware-consumer';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';
 export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -1,3 +1,3 @@
 export { RouteManager } from "./route.manager.js";
 export { MiddlewareBuilder, RequestMethod } from "./middleware-consumer.js";
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController } from "./decorators.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController } from "./decorators.js";

package/dist/http/route.manager.js

@@ -352,10 +352,17 @@ export class RouteManager {
             case ParamType.QUERY:
                 return param.name ? c.req.query(param.name) : c.req.query();
             case ParamType.BODY:
-                try {
-                    return await c.req.json();
-                } catch  {
-                    return undefined;
+                {
+                    let body;
+                    try {
+                        body = await c.req.json();
+                    } catch  {
+                        return undefined;
+                    }
+                    if (param.name && body !== null && typeof body === 'object') {
+                        return body[param.name];
+                    }
+                    return body;
                 }
             case ParamType.HEADERS:
                 if (param.name) {
@@ -432,7 +439,11 @@ export class RouteManager {
                 app.options(normalizedPath, handler);
                 break;
             case HttpMethod.HEAD:
-                app.on('HEAD', normalizedPath, handler);
+                // Hono converts HEAD to GET internally, so register as GET
+                app.get(normalizedPath, handler);
+                break;
+            case HttpMethod.ALL:
+                app.all(normalizedPath, handler);
                 break;
             default:
                 app.on(method.toUpperCase(), normalizedPath, handler);

package/dist/http/types.d.ts

@@ -9,6 +9,7 @@ export interface RouteMetadata {
 }
 export interface ControllerOptions {
     prefix?: string;
+    path?: string;
     version?: number | number[];
 }
 export interface ControllerMetadata {

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { VelaApplication } from './application';
 export { Container, Injectable, Inject, Optional, InjectionToken, ForwardRef, forwardRef, ModuleRef, mixin } from './container/index';
 export type { Type, Token, InjectableOptions, ProviderOptions, } from './container/index';
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from './constants';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, } from './http/index';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, } from './http/index';
 export { Logger, LogLevel } from './services/index';
 export type { LoggerService } from './services/index';
 export { ConfigModule, ConfigService, CONFIG_OPTIONS } from './config/index';

package/dist/index.js

@@ -8,7 +8,7 @@ export { Container, Injectable, Inject, Optional, InjectionToken, ForwardRef, fo
 // Constants
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from "./constants.js";
 // HTTP Decorators
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators } from "./http/index.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators } from "./http/index.js";
 // Services
 export { Logger, LogLevel } from "./services/index.js";
 // Config

package/dist/validation/validation.pipe.js

@@ -7,7 +7,7 @@ export class ValidationPipe {
             return metatype.schema.parse(value);
         } catch (error) {
             if (error && typeof error === 'object' && 'issues' in error && Array.isArray(error.issues)) {
-                throw new BadRequestException('Validation failed', {
+                throw new BadRequestException({
                     statusCode: 400,
                     message: 'Validation failed',
                     errors: error.issues

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",