@velajs/vela 1.19.0 → 1.19.1

package/dist/health/health.http.js

@@ -1,75 +0,0 @@
-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);
-}
-import { Injectable } from "../container/index.js";
-import { HealthIndicatorService } from "./health.indicator.js";
-export class HttpHealthIndicator {
-    indicator;
-    constructor(indicator){
-        this.indicator = indicator;
-    }
-    async pingCheck(key, url, options) {
-        const { method = 'GET', headers, timeout = 5000, expectedStatus } = options ?? {};
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                signal: AbortSignal.timeout(timeout)
-            });
-            const statusCode = response.status;
-            const isHealthy = expectedStatus !== undefined ? statusCode === expectedStatus : statusCode >= 200 && statusCode < 300;
-            if (isHealthy) {
-                return this.indicator.check(key).up({
-                    statusCode
-                });
-            }
-            return this.indicator.check(key).down({
-                statusCode,
-                message: response.statusText
-            });
-        } catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return this.indicator.check(key).down({
-                message
-            });
-        }
-    }
-    async responseCheck(key, url, callback, options) {
-        const { method = 'GET', headers, timeout = 5000 } = options ?? {};
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                signal: AbortSignal.timeout(timeout)
-            });
-            const statusCode = response.status;
-            const isHealthy = await callback(response);
-            if (isHealthy) {
-                return this.indicator.check(key).up({
-                    statusCode
-                });
-            }
-            return this.indicator.check(key).down({
-                statusCode
-            });
-        } catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return this.indicator.check(key).down({
-                message
-            });
-        }
-    }
-}
-HttpHealthIndicator = _ts_decorate([
-    Injectable(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HealthIndicatorService === "undefined" ? Object : HealthIndicatorService
-    ])
-], HttpHealthIndicator);

package/dist/health/health.indicator.d.ts

@@ -1,9 +0,0 @@
-import type { HealthIndicatorResult } from './health.types';
-interface HealthIndicatorBuilder {
-    up(data?: Record<string, unknown>): HealthIndicatorResult;
-    down(data?: Record<string, unknown>): HealthIndicatorResult;
-}
-export declare class HealthIndicatorService {
-    check(key: string): HealthIndicatorBuilder;
-}
-export {};

package/dist/health/health.indicator.js

@@ -1,32 +0,0 @@
-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 { Injectable } from "../container/index.js";
-export class HealthIndicatorService {
-    check(key) {
-        return {
-            up (data) {
-                return {
-                    [key]: {
-                        status: 'up',
-                        ...data
-                    }
-                };
-            },
-            down (data) {
-                return {
-                    [key]: {
-                        status: 'down',
-                        ...data
-                    }
-                };
-            }
-        };
-    }
-}
-HealthIndicatorService = _ts_decorate([
-    Injectable()
-], HealthIndicatorService);

package/dist/health/health.module.d.ts

@@ -1,2 +0,0 @@
-export declare class HealthModule {
-}

package/dist/health/health.module.js

@@ -1,26 +0,0 @@
-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 { Module } from "../module/index.js";
-import { HealthCheckService } from "./health.service.js";
-import { HealthIndicatorService } from "./health.indicator.js";
-import { HttpHealthIndicator } from "./health.http.js";
-export class HealthModule {
-}
-HealthModule = _ts_decorate([
-    Module({
-        providers: [
-            HealthCheckService,
-            HealthIndicatorService,
-            HttpHealthIndicator
-        ],
-        exports: [
-            HealthCheckService,
-            HealthIndicatorService,
-            HttpHealthIndicator
-        ]
-    })
-], HealthModule);

package/dist/health/health.service.d.ts

@@ -1,7 +0,0 @@
-import type { BeforeApplicationShutdown } from '../lifecycle/index';
-import type { HealthCheckResult, HealthIndicatorFunction } from './health.types';
-export declare class HealthCheckService implements BeforeApplicationShutdown {
-    private isShuttingDown;
-    beforeApplicationShutdown(): void;
-    check(indicators: HealthIndicatorFunction[]): Promise<HealthCheckResult>;
-}

package/dist/health/health.service.js

@@ -1,69 +0,0 @@
-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 { Injectable } from "../container/index.js";
-import { ServiceUnavailableException } from "../errors/http-exception.js";
-export class HealthCheckService {
-    isShuttingDown = false;
-    beforeApplicationShutdown() {
-        this.isShuttingDown = true;
-    }
-    async check(indicators) {
-        if (this.isShuttingDown) {
-            const result = {
-                status: 'shutting_down',
-                info: {},
-                error: {},
-                details: {}
-            };
-            throw new ServiceUnavailableException({
-                ...result
-            });
-        }
-        const results = await Promise.allSettled(indicators.map((fn)=>fn()));
-        const info = {};
-        const error = {};
-        const details = {};
-        for (const result of results){
-            if (result.status === 'fulfilled') {
-                const indicatorResult = result.value;
-                for (const [key, value] of Object.entries(indicatorResult)){
-                    details[key] = value;
-                    if (value.status === 'up') {
-                        info[key] = value;
-                    } else {
-                        error[key] = value;
-                    }
-                }
-            } else {
-                const message = result.reason instanceof Error ? result.reason.message : 'Health check failed';
-                const key = 'unknown';
-                const value = {
-                    status: 'down',
-                    message
-                };
-                details[key] = value;
-                error[key] = value;
-            }
-        }
-        const status = Object.keys(error).length > 0 ? 'error' : 'ok';
-        const checkResult = {
-            status,
-            info,
-            error,
-            details
-        };
-        if (status === 'error') {
-            throw new ServiceUnavailableException({
-                ...checkResult
-            });
-        }
-        return checkResult;
-    }
-}
-HealthCheckService = _ts_decorate([
-    Injectable()
-], HealthCheckService);

package/dist/health/health.types.d.ts

@@ -1,15 +0,0 @@
-export type HealthCheckStatus = 'ok' | 'error' | 'shutting_down';
-export interface HealthIndicatorResult {
-    [key: string]: {
-        status: 'up' | 'down';
-        [key: string]: unknown;
-    };
-}
-export interface HealthCheckResult {
-    status: HealthCheckStatus;
-    info: HealthIndicatorResult;
-    error: HealthIndicatorResult;
-    details: HealthIndicatorResult;
-}
-export type HealthIndicatorFunction = () => Promise<HealthIndicatorResult>;
-export type ResponseCheckCallback = (response: Response) => boolean | Promise<boolean>;

package/dist/health/health.types.js

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

package/dist/health/index.d.ts

@@ -1,6 +0,0 @@
-export { HealthModule } from './health.module';
-export { HealthCheckService } from './health.service';
-export { HealthIndicatorService } from './health.indicator';
-export { HttpHealthIndicator } from './health.http';
-export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, } from './health.types';
-export type { HttpPingOptions } from './health.http';

package/dist/health/index.js

@@ -1,4 +0,0 @@
-export { HealthModule } from "./health.module.js";
-export { HealthCheckService } from "./health.service.js";
-export { HealthIndicatorService } from "./health.indicator.js";
-export { HttpHealthIndicator } from "./health.http.js";

package/dist/http/ambient.d.ts

@@ -1,17 +0,0 @@
-import type { MiddlewareHandler } from 'hono';
-import type { Container } from '../container/container';
-import { type RequestContext } from './request-context';
-/**
- * Returns Hono's `contextStorage()` middleware. Register it as the FIRST global
- * middleware so `getCurrentContainer()` works everywhere downstream. When using
- * `VelaFactory.create(module, { ambientContainer: true })` this is wired
- * automatically — call this only for manual/raw Hono setups.
- */
-export declare function enableAmbientContainer(): MiddlewareHandler;
-/**
- * The current request's DI container. Throws with actionable guidance if
- * ambient access isn't enabled or this runs outside a request.
- */
-export declare function getCurrentContainer(): Container;
-/** The current request's {@link RequestContext} (via the ambient container). */
-export declare function getCurrentRequestContext(): RequestContext;

package/dist/http/ambient.js

@@ -1,44 +0,0 @@
-import { contextStorage, getContext } from "hono/context-storage";
-import { REQUEST_CONTEXT } from "./request-context.js";
-// Opt-in ambient access to the per-request DI container / RequestContext,
-// for deep code that lacks the Hono `Context` (services, standalone helpers).
-//
-// Portable across vela's target runtimes because the `node:async_hooks`
-// dependency lives inside Hono's `contextStorage()` middleware — vela's own
-// source never imports `node:*`. Uses only the workerd-safe ALS subset
-// (`run()`/`getStore()`); no `enterWith`, no cross-thenable propagation.
-//
-// Default path is unchanged: request scope is still carried by the per-request
-// child container (see RouteManager.getRequestContainer). This is a second
-// READ path, active only when enabled.
-/**
- * Returns Hono's `contextStorage()` middleware. Register it as the FIRST global
- * middleware so `getCurrentContainer()` works everywhere downstream. When using
- * `VelaFactory.create(module, { ambientContainer: true })` this is wired
- * automatically — call this only for manual/raw Hono setups.
- */ export function enableAmbientContainer() {
-    return contextStorage();
-}
-function tryGetContext() {
-    try {
-        return getContext();
-    } catch  {
-        // Thrown when called outside the contextStorage() middleware (i.e. ambient
-        // access not enabled, or outside a request).
-        return undefined;
-    }
-}
-/**
- * The current request's DI container. Throws with actionable guidance if
- * ambient access isn't enabled or this runs outside a request.
- */ export function getCurrentContainer() {
-    const context = tryGetContext();
-    const container = context?.get('container');
-    if (!container) {
-        throw new Error('getCurrentContainer() is unavailable: enable ambient access via ' + "VelaFactory.create(module, { ambientContainer: true }) (or app.use(enableAmbientContainer())) " + 'and only call it within a request.');
-    }
-    return container;
-}
-/** The current request's {@link RequestContext} (via the ambient container). */ export function getCurrentRequestContext() {
-    return getCurrentContainer().resolve(REQUEST_CONTEXT);
-}

package/dist/http/argument-resolver.d.ts

@@ -1,10 +0,0 @@
-import type { Context } from 'hono';
-import type { Container } from '../container/container';
-import type { PipeTransform } from '../pipeline/types';
-import type { ParamMetadata } from './types';
-export declare class ArgumentResolver {
-    private readonly ipExtractor;
-    constructor(ipExtractor: (c: Context) => string | null);
-    extract(c: Context, paramMetadata: ParamMetadata[], pipes: PipeTransform[], requestContainer: Container, paramTypes?: unknown[]): Promise<unknown[]>;
-    private extractParam;
-}

package/dist/http/argument-resolver.js

@@ -1,89 +0,0 @@
-import { getCookie } from "hono/cookie";
-import { ParamType } from "../constants.js";
-import { instantiate } from "./instantiate.js";
-const PARAM_EXTRACTORS = new Map([
-    [
-        ParamType.PARAM,
-        (c, p)=>p.name ? c.req.param(p.name) : c.req.param()
-    ],
-    [
-        ParamType.QUERY,
-        (c, p)=>p.name ? c.req.query(p.name) : c.req.query()
-    ],
-    [
-        ParamType.BODY,
-        async (c, p)=>{
-            let body;
-            try {
-                body = await c.req.json();
-            } catch  {
-                return undefined;
-            }
-            return p.name && body !== null && typeof body === 'object' ? body[p.name] : body;
-        }
-    ],
-    [
-        ParamType.HEADERS,
-        (c, p)=>p.name ? c.req.header(p.name) : c.req.header()
-    ],
-    [
-        ParamType.REQUEST,
-        (c)=>c
-    ],
-    [
-        ParamType.RESPONSE,
-        (c)=>c
-    ],
-    [
-        ParamType.COOKIE,
-        (c, p)=>p.name ? getCookie(c, p.name) : getCookie(c)
-    ],
-    [
-        ParamType.RAW_BODY,
-        async (c)=>new Uint8Array(await c.req.arrayBuffer())
-    ]
-]);
-// Pulls handler arguments from the request, applies shared pipes (global +
-// controller + method) and then per-param pipes. Empty paramMetadata returns
-// `[c]` to match the old direct-Hono-handler shape — a back-compat behavior
-// the framework's tests rely on.
-export class ArgumentResolver {
-    ipExtractor;
-    constructor(ipExtractor){
-        this.ipExtractor = ipExtractor;
-    }
-    async extract(c, paramMetadata, pipes, requestContainer, paramTypes) {
-        if (paramMetadata.length === 0) {
-            return [
-                c
-            ];
-        }
-        const maxIndex = paramMetadata.at(-1).index;
-        const args = new Array(maxIndex + 1).fill(undefined);
-        for (const param of paramMetadata){
-            let value = await this.extractParam(c, param);
-            const metadata = {
-                type: param.type,
-                data: param.name,
-                metatype: param.metatype ?? paramTypes?.[param.index]
-            };
-            for (const pipe of pipes){
-                value = await pipe.transform(value, metadata);
-            }
-            if (param.pipes && param.pipes.length > 0) {
-                for (const paramPipe of param.pipes){
-                    const pipeInstance = instantiate(paramPipe, requestContainer);
-                    value = await pipeInstance.transform(value, metadata);
-                }
-            }
-            args[param.index] = value;
-        }
-        return args;
-    }
-    extractParam(c, param) {
-        if (param.type === ParamType.IP) return this.ipExtractor(c);
-        const extractor = PARAM_EXTRACTORS.get(param.type);
-        if (extractor) return extractor(c, param);
-        return param.factory ? param.factory(param.name, c) : undefined;
-    }
-}

package/dist/http/decorators.d.ts

@@ -1,198 +0,0 @@
-import type { Constructor, PipeType } from '../registry/types';
-import type { ControllerOptions } from './types';
-import type { ExecutionContext } from '../pipeline/types';
-/**
- * Marks a class as a controller.
- * Accepts a path string or an options object with `path` and `version`.
- *
- * @example
- * ```ts
- * @Controller('/users')
- * @Controller({ path: '/users', version: 1 })
- * @Controller({ path: '/users', version: [1, 2] })
- * ```
- */
-export declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
-/**
- * Override the version for a specific route method.
- *
- * @example
- * ```ts
- * @Controller({ prefix: '/users', version: 1 })
- * class UserController {
- *   @Get()
- *   listV1() { ... }          // GET /v1/users
- *
- *   @Version(2)
- *   @Get()
- *   listV2() { ... }          // GET /v2/users
- * }
- * ```
- */
-export declare function Version(version: number | number[]): MethodDecorator;
-export declare function getRouteVersion(target: Constructor, propertyKey: string | symbol): number | number[] | undefined;
-/** Per-route options for the HTTP method decorators (`@Get`, `@Post`, …). */
-export interface RouteOptions {
-    /**
-     * A stable, human-readable name for this route. Enables URL generation
-     * (`UrlGeneratorService.urlFor(name, …)`), surfaces on `app.describeRoutes()`,
-     * and — when set — becomes the OpenAPI `operationId`.
-     */
-    name?: string;
-}
-export declare const Get: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Post: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Put: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Patch: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Delete: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Options: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Head: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const All: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Sse: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Param: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Body: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Headers: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Req: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Injects the Hono `Context` as the response handle.
- * In Hono, request and response state are unified in the `Context` object,
- * so `@Res()` and `@Req()` both return it.
- *
- * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
- *
- * @example
- * ```ts
- * @Get('/set-cookie')
- * handle(@Res() c: Context) {
- *   c.setCookie('session', 'abc123', { httpOnly: true });
- *   return { ok: true };
- * }
- * ```
- */
-export declare const Res: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Ip: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Cookie: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
- *
- * - `@Cookie()` — all cookies as an object
- * - `@Cookie('token')` — the value of the `token` cookie
- *
- * @example
- * ```ts
- * @Get('/me')
- * handle(@Cookie('session') session: string) { ... }
- * ```
- */
-export declare const Cookies: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Injects the raw request body as a `Uint8Array`.
- * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
- * need the raw bytes before any JSON parsing.
- *
- * @example
- * ```ts
- * @Post('/webhook')
- * async handle(@RawBody() body: Uint8Array) {
- *   const sig = new TextDecoder().decode(body);
- *   // verify HMAC...
- * }
- * ```
- */
-export declare function RawBody(): ParameterDecorator;
-/**
- * Factory for creating custom parameter decorators.
- *
- * @example
- * ```ts
- * const CurrentUser = createParamDecorator(
- *   (data: unknown, ctx: ExecutionContext) => {
- *     const req = ctx.getRequest();
- *     return req.headers.get('x-user-id');
- *   }
- * );
- *
- * // Usage:
- * @Get()
- * handle(@CurrentUser() userId: string) { ... }
- *
- * // With data argument:
- * const Header = createParamDecorator(
- *   (data: string, ctx: ExecutionContext) => {
- *     return ctx.getRequest().headers.get(data);
- *   }
- * );
- *
- * @Get()
- * handle(@Header('x-request-id') requestId: string) { ... }
- * ```
- */
-export declare function createParamDecorator<TData = unknown>(factory: (data: TData, ctx: ExecutionContext) => unknown): (data?: TData, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Override the HTTP status code for a handler's response.
- *
- * @example
- * ```ts
- * @Post()
- * @HttpCode(201)
- * create(@Body() data: CreateDto) { return data; }
- * ```
- */
-export declare function HttpCode(statusCode: number): MethodDecorator;
-/**
- * Set a response header declaratively.
- * Can be applied multiple times to set multiple headers.
- *
- * @example
- * ```ts
- * @Get()
- * @Header('Cache-Control', 'no-cache')
- * @Header('X-Custom', 'value')
- * handle() { return { ok: true }; }
- * ```
- */
-export declare function Header(name: string, value: string): MethodDecorator;
-/**
- * Redirect to another URL. The handler's return value can override the URL.
- *
- * @example
- * ```ts
- * @Get('/old')
- * @Redirect('/new', 301)
- * handleOld() {}
- *
- * // Dynamic redirect — return { url, statusCode? } to override
- * @Get('/go')
- * @Redirect('/default')
- * handleGo(@Query('to') to?: string) {
- *   if (to) return { url: to };
- * }
- * ```
- */
-export declare function Redirect(url: string, statusCode?: number): MethodDecorator;
-export declare function getHttpCode(target: Constructor, method: string | symbol): number | undefined;
-export declare function getResponseHeaders(target: Constructor, method: string | symbol): Array<[string, string]>;
-export declare function getRedirect(target: Constructor, method: string | symbol): {
-    url: string;
-    statusCode: number;
-} | undefined;
-/**
- * Composes multiple decorators into one. Applies them in order (top to bottom),
- * matching how stacked decorators behave when written separately.
- *
- * @example
- * ```ts
- * const Auth = (...roles: string[]) => applyDecorators(
- *   UseGuards(JwtGuard, RolesGuard),
- *   SetMetadata('roles', roles),
- * );
- *
- * @Auth('admin')
- * @Get('/admin')
- * handle() { ... }
- * ```
- */
-export type ComposedDecorator = <T>(target: T, propertyKey?: string | symbol, descriptor?: PropertyDescriptor | number) => void;
-export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ComposedDecorator;
-export declare function isController(target: Constructor): boolean;