@velajs/vela 0.4.3 → 0.5.1

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/factory.js

@@ -1,5 +1,6 @@
 import { VelaApplication } from "./application.js";
 import { Container } from "./container/container.js";
+import { ModuleRef } from "./container/module-ref.js";
 import { RouteManager } from "./http/route.manager.js";
 import { ModuleLoader } from "./module/module-loader.js";
 import { ComponentManager } from "./pipeline/component.manager.js";
@@ -8,9 +9,16 @@ export const VelaFactory = {
     async create (rootModule) {
         const container = new Container();
         container.register({
-            token: Container,
+            provide: Container,
             useValue: container
         });
+        container.register({
+            provide: ModuleRef,
+            useFactory: (c)=>new ModuleRef(c),
+            inject: [
+                Container
+            ]
+        });
         const routeManager = new RouteManager(container);
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
@@ -45,8 +53,9 @@ export const VelaFactory = {
         } else if (container.has(APP_MIDDLEWARE)) {
             routeManager.useGlobalMiddlewareTokens(APP_MIDDLEWARE);
         }
+        routeManager.registerConsumerMiddleware(loader.getConsumerMiddlewareDefinitions());
         const app = new VelaApplication(container, routeManager);
-        const instances = loader.resolveAllInstances();
+        const instances = await loader.resolveAllInstances();
         app.setInstances(instances);
         await app.callOnModuleInit();
         await app.callOnApplicationBootstrap();

package/dist/fetch/fetch.module.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncModuleOptions, DynamicModule } from '../module/types';
+import type { HttpModuleOptions } from './fetch.types';
+export declare class HttpModule {
+    static register(options?: HttpModuleOptions): DynamicModule;
+    static registerAsync(options: AsyncModuleOptions<HttpModuleOptions>): DynamicModule;
+}

package/dist/fetch/fetch.module.js

@@ -0,0 +1,77 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { Module } from "../module/decorators.js";
+import { HttpService, HTTP_MODULE_OPTIONS } from "./fetch.service.js";
+export class HttpModule {
+    static register(options = {}) {
+        const moduleClass = class HttpDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'HttpModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                HttpService,
+                HTTP_MODULE_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    provide: HTTP_MODULE_OPTIONS,
+                    useValue: options
+                },
+                HttpService
+            ]
+        };
+    }
+    static registerAsync(options) {
+        const moduleClass = class HttpAsyncDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'HttpModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            imports: options.imports ?? [],
+            exports: [
+                HttpService,
+                HTTP_MODULE_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    provide: HTTP_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject ?? []
+                },
+                HttpService
+            ]
+        };
+    }
+}
+HttpModule = _ts_decorate([
+    Module({
+        providers: [
+            {
+                provide: HTTP_MODULE_OPTIONS,
+                useValue: {}
+            },
+            HttpService
+        ],
+        exports: [
+            HttpService
+        ]
+    })
+], HttpModule);

package/dist/fetch/fetch.service.d.ts

@@ -0,0 +1,24 @@
+import { InjectionToken } from '../container/index';
+import type { HttpModuleOptions, HttpRequestConfig, HttpResponse, RequestConfig } from './fetch.types';
+export declare const HTTP_MODULE_OPTIONS: InjectionToken<HttpModuleOptions>;
+export declare class HttpRequestException extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly response: Response;
+    constructor(status: number, statusText: string, response: Response);
+}
+export declare class HttpService {
+    private readonly baseURL;
+    private readonly defaultHeaders;
+    private readonly defaultTimeout;
+    constructor(options: HttpModuleOptions);
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    patch<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    head(url: string, config?: RequestConfig): Promise<HttpResponse<void>>;
+    request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+    private buildUrl;
+    private parseBody;
+}

package/dist/fetch/fetch.service.js

@@ -0,0 +1,145 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Inject, Injectable, InjectionToken, Optional } from "../container/index.js";
+export const HTTP_MODULE_OPTIONS = new InjectionToken('HTTP_MODULE_OPTIONS');
+export class HttpRequestException extends Error {
+    status;
+    statusText;
+    response;
+    constructor(status, statusText, response){
+        super(`HTTP ${status} ${statusText}`), this.status = status, this.statusText = statusText, this.response = response;
+        this.name = 'HttpRequestException';
+    }
+}
+export class HttpService {
+    baseURL;
+    defaultHeaders;
+    defaultTimeout;
+    constructor(options){
+        const opts = options ?? {};
+        this.baseURL = opts.baseURL ?? '';
+        this.defaultHeaders = opts.headers ?? {};
+        this.defaultTimeout = opts.timeout;
+    }
+    get(url, config) {
+        return this.request({
+            method: 'GET',
+            url,
+            ...config
+        });
+    }
+    post(url, body, config) {
+        return this.request({
+            method: 'POST',
+            url,
+            body,
+            ...config
+        });
+    }
+    put(url, body, config) {
+        return this.request({
+            method: 'PUT',
+            url,
+            body,
+            ...config
+        });
+    }
+    patch(url, body, config) {
+        return this.request({
+            method: 'PATCH',
+            url,
+            body,
+            ...config
+        });
+    }
+    delete(url, config) {
+        return this.request({
+            method: 'DELETE',
+            url,
+            ...config
+        });
+    }
+    head(url, config) {
+        return this.request({
+            method: 'HEAD',
+            url,
+            ...config
+        });
+    }
+    async request(config) {
+        const fullUrl = this.buildUrl(config.url, config.params);
+        const headers = {
+            ...this.defaultHeaders,
+            ...config.headers
+        };
+        const init = {
+            method: config.method,
+            headers
+        };
+        if (config.body !== undefined) {
+            if (typeof config.body === 'string' || config.body instanceof FormData) {
+                init.body = config.body;
+            } else {
+                init.body = JSON.stringify(config.body);
+                if (!headers['Content-Type'] && !headers['content-type']) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+        }
+        const timeout = config.timeout ?? this.defaultTimeout;
+        if (timeout !== undefined) {
+            init.signal = AbortSignal.timeout(timeout);
+        }
+        const response = await fetch(fullUrl, init);
+        if (!response.ok) {
+            throw new HttpRequestException(response.status, response.statusText, response);
+        }
+        const data = await this.parseBody(response);
+        return {
+            data,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        };
+    }
+    buildUrl(url, params) {
+        const base = this.baseURL ? `${this.baseURL}${url}` : url;
+        if (!params || Object.keys(params).length === 0) return base;
+        const searchParams = new URLSearchParams(Object.entries(params).map(([k, v])=>[
+                k,
+                String(v)
+            ]));
+        return `${base}?${searchParams.toString()}`;
+    }
+    async parseBody(response) {
+        if (response.status === 204 || response.headers.get('content-length') === '0') {
+            return undefined;
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            return response.json();
+        }
+        return response.text();
+    }
+}
+HttpService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Optional()),
+    _ts_param(0, Inject(HTTP_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HttpModuleOptions === "undefined" ? Object : HttpModuleOptions
+    ])
+], HttpService);

package/dist/fetch/fetch.types.d.ts

@@ -0,0 +1,24 @@
+export interface HttpModuleOptions {
+    /** Base URL prepended to all requests. */
+    baseURL?: string;
+    /** Default headers sent with every request. */
+    headers?: Record<string, string>;
+    /** Default timeout in milliseconds (uses AbortSignal.timeout). */
+    timeout?: number;
+}
+export interface RequestConfig {
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean>;
+    timeout?: number;
+}
+export interface HttpRequestConfig extends RequestConfig {
+    method: string;
+    url: string;
+    body?: unknown;
+}
+export interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+}

package/dist/fetch/fetch.types.js

@@ -0,0 +1 @@
+export { };

package/dist/fetch/index.d.ts

@@ -0,0 +1,3 @@
+export { HttpModule } from './fetch.module';
+export { HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from './fetch.service';
+export type { HttpModuleOptions, HttpRequestConfig, HttpResponse, RequestConfig } from './fetch.types';

package/dist/fetch/index.js

@@ -0,0 +1,2 @@
+export { HttpModule } from "./fetch.module.js";
+export { HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from "./fetch.service.js";

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;
     }