@velajs/vela 1.19.0 → 1.19.1

package/dist/pipeline/app-providers.js

@@ -1,43 +0,0 @@
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "./tokens.js";
-// NestJS-style "APP_*" provider convention: each slot maps a well-known DI
-// token to the RouteManager method that installs providers under it as a
-// global component. Module-level @Provide(APP_*) entries expand into
-// synthetic tokens (collected by ModuleLoader); a single @Inject(APP_*)
-// provider falls back to the bare token.
-const SLOTS = [
-    {
-        token: APP_GUARD,
-        bind: (rm)=>rm.useGlobalGuardTokens.bind(rm)
-    },
-    {
-        token: APP_PIPE,
-        bind: (rm)=>rm.useGlobalPipeTokens.bind(rm)
-    },
-    {
-        token: APP_INTERCEPTOR,
-        bind: (rm)=>rm.useGlobalInterceptorTokens.bind(rm)
-    },
-    {
-        token: APP_FILTER,
-        bind: (rm)=>rm.useGlobalFilterTokens.bind(rm)
-    },
-    {
-        token: APP_MIDDLEWARE,
-        bind: (rm)=>rm.useGlobalMiddlewareTokens.bind(rm)
-    }
-];
-/**
- * Bind every APP_* provider registered in the container as a global
- * component on the RouteManager. The single source of truth for app-level
- * pipeline configuration — used by both VelaFactory.create and
- * @velajs/testing's TestingModuleBuilder.compile.
- */ export function bindAppProviders(routeManager, container, loader) {
-    for (const { token, bind } of SLOTS){
-        const collected = loader.getAppProviderTokens(token);
-        if (collected.length > 0) {
-            bind(routeManager)(...collected);
-        } else if (container.has(token)) {
-            bind(routeManager)(token);
-        }
-    }
-}

package/dist/pipeline/component.manager.d.ts

@@ -1,25 +0,0 @@
-import type { Container } from '../container/container';
-import type { ComponentType, ComponentTypeMap, Constructor, FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
-import type { ArgumentMetadata, CanActivate, ExceptionFilter, ExecutionContext, NestInterceptor, NestMiddleware, PipeTransform } from './types';
-/**
- * Component registration + resolution for the controller/handler tiers.
- * App-wide (global) components have exactly ONE source: the per-app
- * `RouteManager` (`APP_*` provider tokens + `useGlobalX()`) — callers merge
- * `routeManager.getGlobalComponents()` with {@link getScopedComponents}.
- *
- * Stateless by design: no process-global container (two apps in one process
- * never cross-talk) — every `resolve*` takes the resolving container.
- */
-export declare class ComponentManager {
-    static registerController<T extends ComponentType>(type: T, controller: Constructor, ...components: ComponentTypeMap[T][]): void;
-    static registerHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol, ...components: ComponentTypeMap[T][]): void;
-    static getScopedComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
-    private static resolveAll;
-    static resolveMiddleware(items: MiddlewareType[], container: Container): NestMiddleware[];
-    static resolveGuards(items: GuardType[], container: Container): CanActivate[];
-    static resolvePipes(items: PipeType[], container: Container): PipeTransform[];
-    static resolveInterceptors(items: InterceptorType[], container: Container): NestInterceptor[];
-    static resolveFilters(items: FilterType[], container: Container): ExceptionFilter[];
-    static executePipes(value: unknown, metadata: ArgumentMetadata, pipes: PipeTransform[]): Promise<unknown>;
-    static runInterceptorChain(interceptors: NestInterceptor[], context: ExecutionContext, coreHandler: () => Promise<unknown>): Promise<unknown>;
-}

package/dist/pipeline/component.manager.js

@@ -1,66 +0,0 @@
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { PipelineRunner } from "./pipeline-runner.js";
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-/**
- * Component registration + resolution for the controller/handler tiers.
- * App-wide (global) components have exactly ONE source: the per-app
- * `RouteManager` (`APP_*` provider tokens + `useGlobalX()`) — callers merge
- * `routeManager.getGlobalComponents()` with {@link getScopedComponents}.
- *
- * Stateless by design: no process-global container (two apps in one process
- * never cross-talk) — every `resolve*` takes the resolving container.
- */ export class ComponentManager {
-    // Scoped registration: controller → handler
-    static registerController(type, controller, ...components) {
-        for (const component of components){
-            MetadataRegistry.registerController(type, controller, component);
-        }
-    }
-    static registerHandler(type, controller, handlerName, ...components) {
-        for (const component of components){
-            MetadataRegistry.registerHandler(type, controller, handlerName, component);
-        }
-    }
-    // Scoped resolution: controller → handler. App-wide components come from
-    // RouteManager (APP_* tokens + useGlobalX()) — merged by the caller.
-    static getScopedComponents(type, controller, handlerName) {
-        return [
-            ...MetadataRegistry.getController(type, controller),
-            ...MetadataRegistry.getHandler(type, controller, handlerName)
-        ];
-    }
-    // Type-specific resolvers — explicit container, always.
-    static resolveAll(items, methodKey, container) {
-        return items.map((item)=>isObject(item) && methodKey in item ? item : container.resolve(item));
-    }
-    static resolveMiddleware(items, container) {
-        return this.resolveAll(items, 'use', container);
-    }
-    static resolveGuards(items, container) {
-        return this.resolveAll(items, 'canActivate', container);
-    }
-    static resolvePipes(items, container) {
-        return this.resolveAll(items, 'transform', container);
-    }
-    static resolveInterceptors(items, container) {
-        return this.resolveAll(items, 'intercept', container);
-    }
-    static resolveFilters(items, container) {
-        return this.resolveAll(items, 'catch', container);
-    }
-    // Pipe execution
-    static async executePipes(value, metadata, pipes) {
-        let transformed = value;
-        for (const pipe of pipes){
-            transformed = await pipe.transform(transformed, metadata);
-        }
-        return transformed;
-    }
-    // Interceptor chain (onion pattern) — canonical implementation lives in
-    // PipelineRunner; kept here as a stable alias.
-    static async runInterceptorChain(interceptors, context, coreHandler) {
-        return PipelineRunner.chainInterceptors(interceptors, context, coreHandler);
-    }
-}

package/dist/pipeline/decorators.d.ts

@@ -1,10 +0,0 @@
-import type { Type } from '../container/types';
-import type { ComponentTypeMap } from '../registry/types';
-export declare function UseMiddleware(...middleware: ComponentTypeMap['middleware'][]): (target: object, propertyKey?: string | symbol) => void;
-export declare function UseGuards(...guards: ComponentTypeMap['guard'][]): (target: object, propertyKey?: string | symbol) => void;
-export declare function UsePipes(...pipes: ComponentTypeMap['pipe'][]): (target: object, propertyKey?: string | symbol) => void;
-export declare function UseInterceptors(...interceptors: ComponentTypeMap['interceptor'][]): (target: object, propertyKey?: string | symbol) => void;
-export declare function UseFilters(...filters: ComponentTypeMap['filter'][]): (target: object, propertyKey?: string | symbol) => void;
-export declare function Catch(...exceptions: Type<Error>[]): ClassDecorator;
-export declare function getCatchTypes(filter: unknown): Type<Error>[];
-export declare function shouldFilterCatch(filter: unknown, exception: unknown): boolean;

package/dist/pipeline/decorators.js

@@ -1,42 +0,0 @@
-import { ComponentManager } from "./component.manager.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-function UseComponent(type, ...components) {
-    return (target, propertyKey)=>{
-        if (propertyKey !== undefined) {
-            ComponentManager.registerHandler(type, target.constructor, propertyKey, ...components);
-        } else {
-            ComponentManager.registerController(type, target, ...components);
-        }
-    };
-}
-export function UseMiddleware(...middleware) {
-    return UseComponent('middleware', ...middleware);
-}
-export function UseGuards(...guards) {
-    return UseComponent('guard', ...guards);
-}
-export function UsePipes(...pipes) {
-    return UseComponent('pipe', ...pipes);
-}
-export function UseInterceptors(...interceptors) {
-    return UseComponent('interceptor', ...interceptors);
-}
-export function UseFilters(...filters) {
-    return UseComponent('filter', ...filters);
-}
-export function Catch(...exceptions) {
-    return (target)=>{
-        MetadataRegistry.setCatchTypes(target, exceptions);
-    };
-}
-export function getCatchTypes(filter) {
-    const filterClass = typeof filter === 'function' ? filter : filter.constructor;
-    return MetadataRegistry.getCatchTypes(filterClass) ?? [];
-}
-export function shouldFilterCatch(filter, exception) {
-    const catchTypes = getCatchTypes(filter);
-    if (catchTypes.length === 0) {
-        return true;
-    }
-    return catchTypes.some((type)=>exception instanceof type);
-}

package/dist/pipeline/index.d.ts

@@ -1,12 +0,0 @@
-export { ComponentManager } from './component.manager';
-export { PipelineRunner } from './pipeline-runner';
-export type { PipelineRunOptions } from './pipeline-runner';
-export { resolveScopedComponents } from './scoped-components';
-export type { ResolvedComponentMap } from './scoped-components';
-export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, getCatchTypes, shouldFilterCatch, } from './decorators';
-export { SetMetadata, Reflector } from './reflector';
-export type { ReflectableDecorator, CreateDecoratorOptions } from './reflector';
-export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, APP_EXCEPTION_HANDLER, ERROR_CATALOG, } from './tokens';
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipes';
-export type { ParseUUIDPipeOptions, ParseArrayPipeOptions } from './pipes';
-export type { HttpArgumentsHost, ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, } from './types';

package/dist/pipeline/index.js

@@ -1,7 +0,0 @@
-export { ComponentManager } from "./component.manager.js";
-export { PipelineRunner } from "./pipeline-runner.js";
-export { resolveScopedComponents } from "./scoped-components.js";
-export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, getCatchTypes, shouldFilterCatch } from "./decorators.js";
-export { SetMetadata, Reflector } from "./reflector.js";
-export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, APP_EXCEPTION_HANDLER, ERROR_CATALOG } from "./tokens.js";
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipes.js";

package/dist/pipeline/pipeline-runner.d.ts

@@ -1,31 +0,0 @@
-import type { CanActivate, ExecutionContext, NestInterceptor } from './types';
-export interface PipelineRunOptions {
-    context: ExecutionContext;
-    /** Pre-merged (global ++ scoped), pre-instantiated. */
-    guards: CanActivate[];
-    interceptors: NestInterceptor[];
-    /** Extract handler arguments (pipes already bound inside the closure). */
-    resolveArgs: () => Promise<unknown[]>;
-    /** Call the actual handler. */
-    invoke: (args: unknown[]) => Promise<unknown>;
-    /**
-     * HTTP runs argument extraction + pipes BEFORE guards (a deliberate vela
-     * deviation — see handler-executor); WebSocket runs guards first. Default
-     * false (guards first).
-     */
-    argsBeforeGuards?: boolean;
-    /** Error thrown when a guard rejects (default `ForbiddenException`). */
-    onGuardReject?: () => Error;
-}
-/**
- * The transport-agnostic guard → pipe → interceptor execution core shared by
- * the HTTP `HandlerExecutor` and the WebSocket `WsDispatcher` (and any future
- * entrypoint dispatcher: queue consumers, scheduled jobs, …). Exception
- * FILTERS stay with the caller — their terminal behavior is transport-specific
- * (HTTP maps to a Response, WS sends an error frame).
- */
-export declare class PipelineRunner {
-    static run(options: PipelineRunOptions): Promise<unknown>;
-    /** Interceptor onion — innermost is the core handler. */
-    static chainInterceptors(interceptors: NestInterceptor[], context: ExecutionContext, coreHandler: () => Promise<unknown>): Promise<unknown>;
-}

package/dist/pipeline/pipeline-runner.js

@@ -1,40 +0,0 @@
-import { ForbiddenException } from "../errors/http-exception.js";
-/**
- * The transport-agnostic guard → pipe → interceptor execution core shared by
- * the HTTP `HandlerExecutor` and the WebSocket `WsDispatcher` (and any future
- * entrypoint dispatcher: queue consumers, scheduled jobs, …). Exception
- * FILTERS stay with the caller — their terminal behavior is transport-specific
- * (HTTP maps to a Response, WS sends an error frame).
- */ export class PipelineRunner {
-    static async run(options) {
-        let args;
-        if (options.argsBeforeGuards) {
-            args = await options.resolveArgs();
-        }
-        for (const guard of options.guards){
-            const canActivate = await guard.canActivate(options.context);
-            if (!canActivate) {
-                throw options.onGuardReject?.() ?? new ForbiddenException();
-            }
-        }
-        args ??= await options.resolveArgs();
-        const resolvedArgs = args;
-        return PipelineRunner.chainInterceptors(options.interceptors, options.context, ()=>options.invoke(resolvedArgs));
-    }
-    /** Interceptor onion — innermost is the core handler. */ static async chainInterceptors(interceptors, context, coreHandler) {
-        if (interceptors.length === 0) {
-            return coreHandler();
-        }
-        let next = {
-            handle: coreHandler
-        };
-        for(let i = interceptors.length - 1; i >= 0; i--){
-            const interceptor = interceptors[i];
-            const currentNext = next;
-            next = {
-                handle: ()=>interceptor.intercept(context, currentNext)
-            };
-        }
-        return next.handle();
-    }
-}

package/dist/pipeline/pipes.d.ts

@@ -1,48 +0,0 @@
-import type { ArgumentMetadata, PipeTransform } from './types';
-export declare class ParseIntPipe implements PipeTransform<string, number> {
-    transform(value: string, metadata: ArgumentMetadata): number;
-}
-export declare class ParseFloatPipe implements PipeTransform<string, number> {
-    transform(value: string, metadata: ArgumentMetadata): number;
-}
-export declare class ParseBoolPipe implements PipeTransform<string, boolean> {
-    transform(value: string, metadata: ArgumentMetadata): boolean;
-}
-export declare class DefaultValuePipe<T = unknown> implements PipeTransform<T | undefined, T> {
-    private readonly defaultValue;
-    constructor(defaultValue: T);
-    transform(value: T | undefined, _metadata: ArgumentMetadata): T;
-}
-export declare class RequiredPipe implements PipeTransform {
-    transform(value: unknown, metadata: ArgumentMetadata): unknown;
-}
-export declare class ZodValidationPipe implements PipeTransform {
-    private readonly schema;
-    constructor(schema: {
-        parse(data: unknown): unknown;
-    });
-    transform(value: unknown, _metadata: ArgumentMetadata): unknown;
-}
-export interface ParseUUIDPipeOptions {
-    version?: '3' | '4' | '5';
-}
-export declare class ParseUUIDPipe implements PipeTransform<string, string> {
-    private readonly options?;
-    constructor(options?: ParseUUIDPipeOptions | undefined);
-    transform(value: string, metadata: ArgumentMetadata): string;
-}
-export declare class ParseEnumPipe<T extends Record<string, string | number>> implements PipeTransform<string, T[keyof T]> {
-    private readonly allowedValues;
-    private readonly valuesLabel;
-    constructor(enumType: T);
-    transform(value: string, metadata: ArgumentMetadata): T[keyof T];
-}
-export interface ParseArrayPipeOptions {
-    separator?: string;
-    optional?: boolean;
-}
-export declare class ParseArrayPipe implements PipeTransform {
-    private readonly options?;
-    constructor(options?: ParseArrayPipeOptions | undefined);
-    transform(value: unknown, metadata: ArgumentMetadata): unknown[];
-}

package/dist/pipeline/pipes.js

@@ -1,104 +0,0 @@
-import { BadRequestException } from "../errors/http-exception.js";
-export class ParseIntPipe {
-    transform(value, metadata) {
-        const parsed = parseInt(value, 10);
-        if (isNaN(parsed)) {
-            throw new BadRequestException(`Validation failed (numeric string expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-        }
-        return parsed;
-    }
-}
-export class ParseFloatPipe {
-    transform(value, metadata) {
-        const parsed = parseFloat(value);
-        if (isNaN(parsed)) {
-            throw new BadRequestException(`Validation failed (float string expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-        }
-        return parsed;
-    }
-}
-export class ParseBoolPipe {
-    transform(value, metadata) {
-        if (value === 'true') return true;
-        if (value === 'false') return false;
-        throw new BadRequestException(`Validation failed (boolean string expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-    }
-}
-export class DefaultValuePipe {
-    defaultValue;
-    constructor(defaultValue){
-        this.defaultValue = defaultValue;
-    }
-    transform(value, _metadata) {
-        return value !== undefined && value !== null ? value : this.defaultValue;
-    }
-}
-export class RequiredPipe {
-    transform(value, metadata) {
-        if (value === undefined || value === null || value === '') {
-            throw new BadRequestException(`Validation failed (value required)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-        }
-        return value;
-    }
-}
-export class ZodValidationPipe {
-    schema;
-    constructor(schema){
-        this.schema = schema;
-    }
-    transform(value, _metadata) {
-        return this.schema.parse(value);
-    }
-}
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const UUID_VERSION_REGEX = {
-    '3': /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    '4': /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    '5': /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
-};
-export class ParseUUIDPipe {
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    transform(value, metadata) {
-        const regex = this.options?.version ? UUID_VERSION_REGEX[this.options.version] : UUID_REGEX;
-        if (!regex.test(value)) {
-            throw new BadRequestException(`Validation failed (uuid${this.options?.version ? ` v${this.options.version}` : ''} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-        }
-        return value;
-    }
-}
-export class ParseEnumPipe {
-    allowedValues;
-    valuesLabel;
-    constructor(enumType){
-        const values = Object.values(enumType);
-        this.allowedValues = new Set(values);
-        this.valuesLabel = values.join(', ');
-    }
-    transform(value, metadata) {
-        if (!this.allowedValues.has(value)) {
-            throw new BadRequestException(`Validation failed (${this.valuesLabel} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-        }
-        return value;
-    }
-}
-export class ParseArrayPipe {
-    options;
-    constructor(options){
-        this.options = options;
-    }
-    transform(value, metadata) {
-        if (value === undefined || value === null || value === '') {
-            if (this.options?.optional) return [];
-            throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-        }
-        if (Array.isArray(value)) return value;
-        if (typeof value === 'string') {
-            const sep = this.options?.separator ?? ',';
-            return value.split(sep).map((v)=>v.trim()).filter((v)=>v.length > 0);
-        }
-        throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
-    }
-}

package/dist/pipeline/reflector.d.ts

@@ -1,86 +0,0 @@
-import type { ExecutionContext } from './types';
-export interface CreateDecoratorOptions {
-    key?: string;
-}
-export interface ReflectableDecorator<TParam> {
-    (value: TParam): ClassDecorator & MethodDecorator;
-    KEY: string;
-}
-/**
- * Decorator that attaches custom metadata to a class or method.
- * Read via Reflector in guards/interceptors.
- *
- * @example
- * ```ts
- * const Roles = (...roles: string[]) => SetMetadata('roles', roles);
- *
- * @Controller('/admin')
- * @Roles('admin')
- * class AdminController { ... }
- * ```
- */
-export declare function SetMetadata<V = unknown>(key: string, value: V): (target: object, propertyKey?: string | symbol) => void;
-/**
- * Reads custom metadata set by @SetMetadata().
- * Use in guards/interceptors via ExecutionContext.
- *
- * @example
- * ```ts
- * class RolesGuard implements CanActivate {
- *   private reflector = new Reflector();
- *
- *   canActivate(context: ExecutionContext): boolean {
- *     const roles = this.reflector.get<string[]>('roles', context);
- *     if (!roles) return true;
- *     const user = ...; // extract from request
- *     return roles.some(r => user.roles.includes(r));
- *   }
- * }
- * ```
- */
-export declare class Reflector {
-    /**
-     * Create a type-safe decorator that sets metadata with a typed key.
-     *
-     * @example
-     * ```ts
-     * const Roles = Reflector.createDecorator<string[]>();
-     * // Roles(['admin']) — class or method decorator
-     * // reflector.get(Roles, context) — typed as string[] | undefined
-     * ```
-     */
-    static createDecorator<TParam = unknown>(options?: CreateDecoratorOptions): ReflectableDecorator<TParam>;
-    private resolveKey;
-    /**
-     * Get metadata value from handler first, then class.
-     * Handler-level metadata takes priority over class-level.
-     */
-    get<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
-    /**
-     * Get metadata only from the handler (method) level.
-     */
-    getHandler<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
-    /**
-     * Get metadata only from the class level.
-     */
-    getClass<T = unknown>(key: string | ReflectableDecorator<T>, context: Pick<ExecutionContext, "getClass">): T | undefined;
-    /**
-     * Get all metadata values for a key from both handler and class.
-     * Returns [handlerValue, classValue] (either may be undefined).
-     */
-    getAll<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): [T | undefined, T | undefined];
-    /**
-     * Returns handler value if defined, else class value, else undefined.
-     * First defined value wins.
-     */
-    getAllAndOverride<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
-    /**
-     * Collects handler + class values, filters undefineds.
-     * - 0 values → []
-     * - 1 value → return it
-     * - Arrays → concatenate
-     * - Objects → Object.assign({}, ...values)
-     * - Otherwise → wrap in array
-     */
-    getAllAndMerge<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | T[];
-}

package/dist/pipeline/reflector.js

@@ -1,121 +0,0 @@
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-/**
- * Decorator that attaches custom metadata to a class or method.
- * Read via Reflector in guards/interceptors.
- *
- * @example
- * ```ts
- * const Roles = (...roles: string[]) => SetMetadata('roles', roles);
- *
- * @Controller('/admin')
- * @Roles('admin')
- * class AdminController { ... }
- * ```
- */ export function SetMetadata(key, value) {
-    return (target, propertyKey)=>{
-        if (propertyKey !== undefined) {
-            MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, key, value);
-        } else {
-            MetadataRegistry.setCustomClassMeta(target, key, value);
-        }
-    };
-}
-/**
- * Reads custom metadata set by @SetMetadata().
- * Use in guards/interceptors via ExecutionContext.
- *
- * @example
- * ```ts
- * class RolesGuard implements CanActivate {
- *   private reflector = new Reflector();
- *
- *   canActivate(context: ExecutionContext): boolean {
- *     const roles = this.reflector.get<string[]>('roles', context);
- *     if (!roles) return true;
- *     const user = ...; // extract from request
- *     return roles.some(r => user.roles.includes(r));
- *   }
- * }
- * ```
- */ export class Reflector {
-    /**
-   * Create a type-safe decorator that sets metadata with a typed key.
-   *
-   * @example
-   * ```ts
-   * const Roles = Reflector.createDecorator<string[]>();
-   * // Roles(['admin']) — class or method decorator
-   * // reflector.get(Roles, context) — typed as string[] | undefined
-   * ```
-   */ static createDecorator(options) {
-        const key = options?.key ?? `vela:custom:${crypto.randomUUID()}`;
-        const decorator = (value)=>SetMetadata(key, value);
-        decorator.KEY = key;
-        return decorator;
-    }
-    resolveKey(keyOrDecorator) {
-        return typeof keyOrDecorator === 'string' ? keyOrDecorator : keyOrDecorator.KEY;
-    }
-    /**
-   * Get metadata value from handler first, then class.
-   * Handler-level metadata takes priority over class-level.
-   */ get(key, context) {
-        const resolvedKey = this.resolveKey(key);
-        const ctor = context.getClass();
-        const handlerValue = MetadataRegistry.getCustomHandlerMeta(ctor, context.getHandler(), resolvedKey);
-        if (handlerValue !== undefined) return handlerValue;
-        return MetadataRegistry.getCustomClassMeta(ctor, resolvedKey);
-    }
-    /**
-   * Get metadata only from the handler (method) level.
-   */ getHandler(key, context) {
-        const resolvedKey = this.resolveKey(key);
-        return MetadataRegistry.getCustomHandlerMeta(context.getClass(), context.getHandler(), resolvedKey);
-    }
-    /**
-   * Get metadata only from the class level.
-   */ getClass(key, context) {
-        const resolvedKey = this.resolveKey(key);
-        return MetadataRegistry.getCustomClassMeta(context.getClass(), resolvedKey);
-    }
-    /**
-   * Get all metadata values for a key from both handler and class.
-   * Returns [handlerValue, classValue] (either may be undefined).
-   */ getAll(key, context) {
-        return [
-            this.getHandler(key, context),
-            this.getClass(key, context)
-        ];
-    }
-    /**
-   * Returns handler value if defined, else class value, else undefined.
-   * First defined value wins.
-   */ getAllAndOverride(key, context) {
-        return this.getHandler(key, context) ?? this.getClass(key, context);
-    }
-    /**
-   * Collects handler + class values, filters undefineds.
-   * - 0 values → []
-   * - 1 value → return it
-   * - Arrays → concatenate
-   * - Objects → Object.assign({}, ...values)
-   * - Otherwise → wrap in array
-   */ getAllAndMerge(key, context) {
-        const [handlerValue, classValue] = this.getAll(key, context);
-        const values = [];
-        if (handlerValue !== undefined) values.push(handlerValue);
-        if (classValue !== undefined) values.push(classValue);
-        if (values.length === 0) return [];
-        if (values.length === 1) return values[0];
-        if (Array.isArray(values[0]) && Array.isArray(values[1])) {
-            return [
-                ...values[0],
-                ...values[1]
-            ];
-        }
-        if (typeof values[0] === 'object' && values[0] !== null && !Array.isArray(values[0]) && typeof values[1] === 'object' && values[1] !== null && !Array.isArray(values[1])) {
-            return Object.assign({}, values[0], values[1]);
-        }
-        return values;
-    }
-}