@velajs/vela 0.2.1

package/dist/container/types.js

@@ -0,0 +1,11 @@
+export class InjectionToken {
+    description;
+    options;
+    constructor(description, options){
+        this.description = description;
+        this.options = options;
+    }
+    toString() {
+        return `InjectionToken(${this.description})`;
+    }
+}

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

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

package/dist/errors/http-exception.js

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

package/dist/errors/index.d.ts

@@ -0,0 +1 @@
+export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './http-exception';

package/dist/errors/index.js

@@ -0,0 +1 @@
+export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException } from "./http-exception.js";

package/dist/factory.d.ts

@@ -0,0 +1,5 @@
+import { VelaApplication } from './application';
+import type { Type } from './container/types';
+export declare const VelaFactory: {
+    create(rootModule: Type): Promise<VelaApplication>;
+};

package/dist/factory.js

@@ -0,0 +1,39 @@
+import { VelaApplication } from "./application.js";
+import { Container } from "./container/container.js";
+import { RouteManager } from "./http/route.manager.js";
+import { ModuleLoader } from "./module/module-loader.js";
+import { ComponentManager } from "./pipeline/component.manager.js";
+import { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/tokens.js";
+export const VelaFactory = {
+    async create (rootModule) {
+        const container = new Container();
+        const routeManager = new RouteManager(container);
+        ComponentManager.init(container);
+        const loader = new ModuleLoader(container, routeManager);
+        loader.load(rootModule);
+        // Resolve APP_* tokens registered via module providers
+        if (container.has(APP_GUARD)) {
+            routeManager.useGlobalGuards(container.resolve(APP_GUARD));
+        }
+        if (container.has(APP_PIPE)) {
+            routeManager.useGlobalPipes(container.resolve(APP_PIPE));
+        }
+        if (container.has(APP_INTERCEPTOR)) {
+            routeManager.useGlobalInterceptors(container.resolve(APP_INTERCEPTOR));
+        }
+        if (container.has(APP_FILTER)) {
+            routeManager.useGlobalFilters(container.resolve(APP_FILTER));
+        }
+        if (container.has(APP_MIDDLEWARE)) {
+            routeManager.useGlobalMiddleware(container.resolve(APP_MIDDLEWARE));
+        }
+        const app = new VelaApplication(container, routeManager);
+        const instances = loader.resolveAllInstances();
+        app.setInstances(instances);
+        await app.callOnModuleInit();
+        await app.callOnApplicationBootstrap();
+        // Build routes (async — supports CRUD integration with dynamic imports)
+        await app.initRoutes();
+        return app;
+    }
+};

package/dist/http/decorators.d.ts

@@ -0,0 +1,122 @@
+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 prefix string or an options object with prefix and version.
+ *
+ * @example
+ * ```ts
+ * @Controller('/users')
+ * @Controller({ prefix: '/users', version: 1 })
+ * @Controller({ prefix: '/users', version: [1, 2] })
+ * ```
+ */
+export declare function Controller(prefixOrOptions?: 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;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+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 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;
+/**
+ * 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;
+export declare function isController(target: Constructor): boolean;

package/dist/http/decorators.js

@@ -0,0 +1,276 @@
+import { HttpMethod, METADATA_KEYS, ParamType, Scope } from "../constants.js";
+import { defineMetadata, getMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+function normalizePath(path) {
+    return path && !path.startsWith('/') ? `/${path}` : path;
+}
+/**
+ * Marks a class as a controller.
+ * Accepts a prefix string or an options object with prefix and version.
+ *
+ * @example
+ * ```ts
+ * @Controller('/users')
+ * @Controller({ prefix: '/users', version: 1 })
+ * @Controller({ prefix: '/users', version: [1, 2] })
+ * ```
+ */ export function Controller(prefixOrOptions) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return (target)=>{
+        let prefix;
+        let version;
+        if (typeof prefixOrOptions === 'string') {
+            prefix = prefixOrOptions;
+        } else if (prefixOrOptions) {
+            prefix = prefixOrOptions.prefix ?? '';
+            version = prefixOrOptions.version;
+        } else {
+            prefix = '';
+        }
+        MetadataRegistry.setControllerPath(target, normalizePath(prefix));
+        if (version !== undefined) {
+            MetadataRegistry.setControllerOptions(target, {
+                version
+            });
+        }
+        MetadataRegistry.markInjectable(target);
+        MetadataRegistry.setScope(target, Scope.SINGLETON);
+        // Keep WeakMap write for external package compat
+        defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+        defineMetadata(METADATA_KEYS.SCOPE, Scope.SINGLETON, target);
+    };
+}
+/**
+ * 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 function Version(version) {
+    return (target, propertyKey, _descriptor)=>{
+        MetadataRegistry.setRouteVersion(target.constructor, propertyKey, version);
+        // Keep WeakMap write for compat
+        const versionKey = `vela:route-version:${String(propertyKey)}`;
+        defineMetadata(versionKey, version, target.constructor);
+        // If route was already registered (decorator ran after @Get), patch it
+        const routes = MetadataRegistry.getRoutes(target.constructor);
+        const route = routes.find((r)=>r.handlerName === propertyKey);
+        if (route) {
+            route.version = version;
+        }
+    };
+}
+export function getRouteVersion(target, propertyKey) {
+    return MetadataRegistry.getRouteVersion(target, propertyKey) ?? getMetadata(`vela:route-version:${String(propertyKey)}`, target);
+}
+function createMethodDecorator(method) {
+    return (path = '')=>{
+        return (target, propertyKey, _descriptor)=>{
+            const normalizedPath = normalizePath(path);
+            // Check for @Version metadata on this method
+            const version = MetadataRegistry.getRouteVersion(target.constructor, propertyKey) ?? getMetadata(`vela:route-version:${String(propertyKey)}`, target.constructor);
+            MetadataRegistry.addRoute(target.constructor, {
+                method: method,
+                path: normalizedPath,
+                handlerName: propertyKey,
+                ...version !== undefined ? {
+                    version
+                } : {}
+            });
+        };
+    };
+}
+export const Get = createMethodDecorator(HttpMethod.GET);
+export const Post = createMethodDecorator(HttpMethod.POST);
+export const Put = createMethodDecorator(HttpMethod.PUT);
+export const Patch = createMethodDecorator(HttpMethod.PATCH);
+export const Delete = createMethodDecorator(HttpMethod.DELETE);
+export const Options = createMethodDecorator(HttpMethod.OPTIONS);
+export const Head = createMethodDecorator(HttpMethod.HEAD);
+// Parameter decorators
+const CUSTOM_PARAM_TYPE = 'custom';
+function createBuiltinParamDecorator(type) {
+    return (nameOrPipe, ...pipes)=>{
+        return (target, propertyKey, parameterIndex)=>{
+            if (propertyKey === undefined) {
+                throw new Error('Parameter decorators can only be used on method parameters');
+            }
+            let name;
+            let allPipes;
+            if (typeof nameOrPipe === 'string') {
+                name = nameOrPipe;
+                allPipes = pipes;
+            } else if (nameOrPipe !== undefined) {
+                name = undefined;
+                allPipes = [
+                    nameOrPipe,
+                    ...pipes
+                ];
+            } else {
+                name = undefined;
+                allPipes = pipes;
+            }
+            MetadataRegistry.addParameter(target.constructor, propertyKey, {
+                index: parameterIndex,
+                type,
+                name,
+                ...allPipes.length > 0 ? {
+                    pipes: allPipes
+                } : {}
+            });
+        };
+    };
+}
+export const Param = createBuiltinParamDecorator(ParamType.PARAM);
+export const Query = createBuiltinParamDecorator(ParamType.QUERY);
+export const Body = createBuiltinParamDecorator(ParamType.BODY);
+export const Headers = createBuiltinParamDecorator(ParamType.HEADERS);
+export const Req = createBuiltinParamDecorator(ParamType.REQUEST);
+/**
+ * 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 function createParamDecorator(factory) {
+    return (data, ...pipes)=>{
+        return (target, propertyKey, parameterIndex)=>{
+            if (propertyKey === undefined) {
+                throw new Error('Parameter decorators can only be used on method parameters');
+            }
+            MetadataRegistry.addParameter(target.constructor, propertyKey, {
+                index: parameterIndex,
+                type: CUSTOM_PARAM_TYPE,
+                name: undefined,
+                factory: (_unused, ctx)=>{
+                    const honoCtx = ctx;
+                    const execCtx = {
+                        getClass: ()=>target.constructor,
+                        getHandler: ()=>propertyKey,
+                        getContext: ()=>honoCtx,
+                        getRequest: ()=>honoCtx.req.raw
+                    };
+                    return factory(data, execCtx);
+                },
+                ...pipes.length > 0 ? {
+                    pipes
+                } : {}
+            });
+        };
+    };
+}
+// Response decorators
+/**
+ * Override the HTTP status code for a handler's response.
+ *
+ * @example
+ * ```ts
+ * @Post()
+ * @HttpCode(201)
+ * create(@Body() data: CreateDto) { return data; }
+ * ```
+ */ export function HttpCode(statusCode) {
+    return (target, propertyKey, _descriptor)=>{
+        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
+            httpCode: statusCode
+        });
+    };
+}
+/**
+ * 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 function Header(name, value) {
+    return (target, propertyKey, _descriptor)=>{
+        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
+            responseHeaders: [
+                [
+                    name,
+                    value
+                ]
+            ]
+        });
+    };
+}
+/**
+ * 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 function Redirect(url, statusCode = 302) {
+    return (target, propertyKey, _descriptor)=>{
+        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
+            redirect: {
+                url,
+                statusCode
+            }
+        });
+    };
+}
+// Metadata readers (used by RouteManager)
+export function getHttpCode(target, method) {
+    const meta = MetadataRegistry.getHandlerHttpMeta(target, method);
+    if (meta?.httpCode !== undefined) return meta.httpCode;
+    return getMetadata(METADATA_KEYS.HTTP_CODE, target, method);
+}
+export function getResponseHeaders(target, method) {
+    const meta = MetadataRegistry.getHandlerHttpMeta(target, method);
+    if (meta?.responseHeaders) return meta.responseHeaders;
+    return getMetadata(METADATA_KEYS.RESPONSE_HEADERS, target, method) ?? [];
+}
+export function getRedirect(target, method) {
+    const meta = MetadataRegistry.getHandlerHttpMeta(target, method);
+    if (meta?.redirect) return meta.redirect;
+    return getMetadata(METADATA_KEYS.REDIRECT, target, method);
+}
+// Helpers
+export function isController(target) {
+    return MetadataRegistry.getControllerPath(target) !== '' || MetadataRegistry.getRoutes(target).length > 0;
+}

package/dist/http/index.d.ts

@@ -0,0 +1,3 @@
+export { RouteManager } from './route.manager';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController, } from './decorators';
+export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -0,0 +1,2 @@
+export { RouteManager } from "./route.manager.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController } from "./decorators.js";