@velajs/vela 0.1.0

package/dist/http/route.manager.d.ts

@@ -0,0 +1,34 @@
+import { Hono } from 'hono';
+import type { Container } from '../container/container';
+import type { Type } from '../container/types';
+import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
+import type { ControllerRegistration } from './types';
+export declare class RouteManager {
+    private container;
+    private controllers;
+    private globalMiddleware;
+    private globalPipes;
+    private globalGuards;
+    private globalInterceptors;
+    private globalFilters;
+    private globalPrefix;
+    constructor(container: Container);
+    setGlobalPrefix(prefix: string): this;
+    useGlobalMiddleware(...middleware: MiddlewareType[]): this;
+    useGlobalPipes(...pipes: PipeType[]): this;
+    useGlobalGuards(...guards: GuardType[]): this;
+    useGlobalInterceptors(...interceptors: InterceptorType[]): this;
+    useGlobalFilters(...filters: FilterType[]): this;
+    private instantiate;
+    registerController(controller: Type): this;
+    build(): Promise<Hono>;
+    private createExecutionContext;
+    private createHandler;
+    private extractArguments;
+    private extractParam;
+    private createResponse;
+    private registerRoute;
+    private buildVersionedPaths;
+    private joinPaths;
+    getControllers(): ControllerRegistration[];
+}

package/dist/http/route.manager.js

@@ -0,0 +1,373 @@
+import { Hono } from "hono";
+import { HttpMethod, ParamType } from "../constants.js";
+import { getMetadata } from "../metadata.js";
+import { ForbiddenException, HttpException } from "../errors/http-exception.js";
+import { ComponentManager } from "../pipeline/component.manager.js";
+import { shouldFilterCatch } from "../pipeline/decorators.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { getHttpCode, getRedirect, getResponseHeaders } from "./decorators.js";
+function parseRedirectResult(result) {
+    if (typeof result !== 'object' || result === null) return undefined;
+    if (!('url' in result)) return undefined;
+    const obj = result;
+    if (typeof obj.url !== 'string') return undefined;
+    return {
+        url: obj.url,
+        ...typeof obj.statusCode === 'number' ? {
+            statusCode: obj.statusCode
+        } : {}
+    };
+}
+export class RouteManager {
+    container;
+    controllers = [];
+    globalMiddleware = [];
+    globalPipes = [];
+    globalGuards = [];
+    globalInterceptors = [];
+    globalFilters = [];
+    globalPrefix = '';
+    constructor(container){
+        this.container = container;
+    }
+    setGlobalPrefix(prefix) {
+        this.globalPrefix = prefix && !prefix.startsWith('/') ? `/${prefix}` : prefix;
+        return this;
+    }
+    useGlobalMiddleware(...middleware) {
+        for (const mw of middleware){
+            this.globalMiddleware.push(this.instantiate(mw));
+        }
+        return this;
+    }
+    useGlobalPipes(...pipes) {
+        for (const pipe of pipes){
+            this.globalPipes.push(this.instantiate(pipe));
+        }
+        return this;
+    }
+    useGlobalGuards(...guards) {
+        for (const guard of guards){
+            this.globalGuards.push(this.instantiate(guard));
+        }
+        return this;
+    }
+    useGlobalInterceptors(...interceptors) {
+        for (const interceptor of interceptors){
+            this.globalInterceptors.push(this.instantiate(interceptor));
+        }
+        return this;
+    }
+    useGlobalFilters(...filters) {
+        for (const filter of filters){
+            this.globalFilters.push(this.instantiate(filter));
+        }
+        return this;
+    }
+    instantiate(classOrInstance) {
+        if (typeof classOrInstance !== 'function') {
+            return classOrInstance;
+        }
+        if (this.container.has(classOrInstance)) {
+            return this.container.resolve(classOrInstance);
+        }
+        return new classOrInstance();
+    }
+    registerController(controller) {
+        const prefix = MetadataRegistry.getControllerPath(controller);
+        const options = MetadataRegistry.getControllerOptions(controller);
+        const routes = MetadataRegistry.getRoutes(controller);
+        if (!this.container.has(controller)) {
+            this.container.register(controller);
+        }
+        this.controllers.push({
+            controller,
+            metadata: {
+                prefix,
+                version: options.version
+            },
+            routes: routes
+        });
+        return this;
+    }
+    async build() {
+        const app = new Hono();
+        // Register global middleware on the Hono app
+        for (const mw of this.globalMiddleware){
+            app.use('*', (c, next)=>mw.use(c, next));
+        }
+        // First pass: register all custom routes (must come before CRUD /:id routes)
+        for (const { controller, metadata, routes } of this.controllers){
+            if (routes.length > 0) {
+                const instance = this.container.resolve(controller);
+                const allParamMetadata = MetadataRegistry.getParameters(controller);
+                for (const route of routes){
+                    // Determine effective version: route-level overrides controller-level
+                    const effectiveVersion = route.version ?? metadata.version;
+                    // Build versioned paths
+                    const versionedPaths = this.buildVersionedPaths(this.globalPrefix, metadata.prefix, route.path, effectiveVersion);
+                    // Register per-route middleware as Hono middleware before the handler
+                    const middlewareItems = ComponentManager.getComponents('middleware', controller, route.handlerName);
+                    const resolvedMw = ComponentManager.resolveMiddleware(middlewareItems);
+                    const handler = this.createHandler(instance, route, controller, allParamMetadata);
+                    for (const fullPath of versionedPaths){
+                        for (const mw of resolvedMw){
+                            app.use(fullPath, (c, next)=>mw.use(c, next));
+                        }
+                        this.registerRoute(app, route.method, fullPath, handler);
+                    }
+                }
+            }
+        }
+        // Second pass: mount CRUD sub-apps (/:id routes registered last)
+        for (const { controller, metadata } of this.controllers){
+            const crudConfig = getMetadata('vela:crud', controller);
+            if (crudConfig) {
+                try {
+                    const pkg = '@velajs/crud';
+                    const { buildCrudRoutes } = await import(pkg);
+                    await buildCrudRoutes(app, controller, metadata.prefix, crudConfig, {
+                        globalPrefix: this.globalPrefix,
+                        globalGuards: this.globalGuards,
+                        joinPaths: this.joinPaths.bind(this)
+                    });
+                } catch  {
+                    throw new Error(`@Crud() requires '@velajs/crud'. Install it: bun add @velajs/crud`);
+                }
+            }
+        }
+        return app;
+    }
+    createExecutionContext(c, controller, route) {
+        return {
+            getClass: ()=>controller,
+            getHandler: ()=>route.handlerName,
+            getContext: ()=>c,
+            getRequest: ()=>c.req.raw
+        };
+    }
+    createHandler(instance, route, controller, allParamMetadata) {
+        const paramMetadata = (allParamMetadata.get(route.handlerName) || []).sort((a, b)=>a.index - b.index);
+        // Pre-resolve controller + method level components at build time
+        const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
+        const methodPipes = ComponentManager.getComponents('pipe', controller, route.handlerName);
+        const methodInterceptors = ComponentManager.getComponents('interceptor', controller, route.handlerName);
+        const methodFilters = ComponentManager.getComponents('filter', controller, route.handlerName);
+        const resolvedMethodGuards = ComponentManager.resolveGuards(methodGuards);
+        const resolvedMethodPipes = ComponentManager.resolvePipes(methodPipes);
+        const resolvedMethodInterceptors = ComponentManager.resolveInterceptors(methodInterceptors);
+        // Filters: reverse order (handler → controller → global) — closest to handler runs first
+        const resolvedMethodFilters = ComponentManager.resolveFilters([
+            ...methodFilters
+        ].reverse());
+        // Read response decorators at build time
+        const httpCode = getHttpCode(controller, route.handlerName);
+        const responseHeaders = getResponseHeaders(controller, route.handlerName);
+        const redirect = getRedirect(controller, route.handlerName);
+        return async (c)=>{
+            // Create a child container for request-scoped providers
+            const requestContainer = this.container.createChild();
+            c.set('container', requestContainer);
+            // Combine global + method at request time (allows post-create registration)
+            const guards = [
+                ...this.globalGuards,
+                ...resolvedMethodGuards
+            ];
+            const pipes = [
+                ...this.globalPipes,
+                ...resolvedMethodPipes
+            ];
+            const interceptors = [
+                ...this.globalInterceptors,
+                ...resolvedMethodInterceptors
+            ];
+            const filters = [
+                ...resolvedMethodFilters,
+                ...this.globalFilters
+            ];
+            const executionContext = this.createExecutionContext(c, controller, route);
+            try {
+                // 1. Extract args + run pipes
+                const args = await this.extractArguments(c, paramMetadata, pipes);
+                // 2. Guards (fail-fast)
+                for (const guard of guards){
+                    const canActivate = await guard.canActivate(executionContext);
+                    if (!canActivate) {
+                        throw new ForbiddenException();
+                    }
+                }
+                // 3. Get handler method
+                const method = Reflect.get(instance, route.handlerName);
+                if (typeof method !== 'function') {
+                    throw new Error(`Method ${String(route.handlerName)} not found on controller`);
+                }
+                // 4. Build core handler
+                const coreHandler = async ()=>Reflect.apply(method, instance, args);
+                // 5. Run interceptor chain
+                const result = await ComponentManager.runInterceptorChain(interceptors, executionContext, coreHandler);
+                // Handle @Redirect
+                if (redirect) {
+                    const overrides = parseRedirectResult(result);
+                    const finalUrl = overrides?.url ?? redirect.url;
+                    const finalStatus = overrides?.statusCode ?? redirect.statusCode;
+                    return c.redirect(finalUrl, finalStatus);
+                }
+                // Build response with @HttpCode and @Header support
+                const response = this.createResponse(c, result, httpCode);
+                // Apply @Header decorators
+                for (const [headerName, headerValue] of responseHeaders){
+                    response.headers.set(headerName, headerValue);
+                }
+                return response;
+            } catch (error) {
+                // Run exception filters
+                for (const filter of filters){
+                    if (shouldFilterCatch(filter, error)) {
+                        try {
+                            const result = await filter.catch(error, executionContext);
+                            return this.createResponse(c, result);
+                        } catch  {
+                            break;
+                        }
+                    }
+                }
+                // Default HttpException handling
+                if (error instanceof HttpException) {
+                    const response = error.getResponse();
+                    const status = error.getStatus();
+                    return c.json(response, status);
+                }
+                // Default 500
+                return c.json({
+                    statusCode: 500,
+                    message: 'Internal Server Error'
+                }, 500);
+            }
+        };
+    }
+    async extractArguments(c, paramMetadata, pipes) {
+        if (paramMetadata.length === 0) {
+            return [
+                c
+            ];
+        }
+        const maxIndex = Math.max(...paramMetadata.map((p)=>p.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: undefined
+            };
+            // Run shared pipes (global + controller + method)
+            for (const pipe of pipes){
+                value = await pipe.transform(value, metadata);
+            }
+            // Run param-level pipes
+            if (param.pipes && param.pipes.length > 0) {
+                for (const paramPipe of param.pipes){
+                    const pipeInstance = this.instantiate(paramPipe);
+                    value = await pipeInstance.transform(value, metadata);
+                }
+            }
+            args[param.index] = value;
+        }
+        return args;
+    }
+    async extractParam(c, param) {
+        switch(param.type){
+            case ParamType.PARAM:
+                return param.name ? c.req.param(param.name) : c.req.param();
+            case ParamType.QUERY:
+                return param.name ? c.req.query(param.name) : c.req.query();
+            case ParamType.BODY:
+                try {
+                    return await c.req.json();
+                } catch  {
+                    return undefined;
+                }
+            case ParamType.HEADERS:
+                if (param.name) {
+                    return c.req.header(param.name);
+                }
+                const headers = {};
+                c.req.raw.headers.forEach((value, key)=>{
+                    headers[key] = value;
+                });
+                return headers;
+            case ParamType.REQUEST:
+                return c;
+            default:
+                // Custom param decorator — use factory if available
+                if (param.factory) {
+                    return param.factory(param.name, c);
+                }
+                return undefined;
+        }
+    }
+    createResponse(c, result, statusCode) {
+        if (result instanceof Response) {
+            return result;
+        }
+        if (result === null || result === undefined) {
+            return c.body(null, statusCode ?? 204);
+        }
+        if (typeof result === 'string') {
+            return c.text(result, statusCode ?? 200);
+        }
+        return c.json(result, statusCode ?? 200);
+    }
+    registerRoute(app, method, path, handler) {
+        const normalizedPath = path || '/';
+        switch(method){
+            case HttpMethod.GET:
+                app.get(normalizedPath, handler);
+                break;
+            case HttpMethod.POST:
+                app.post(normalizedPath, handler);
+                break;
+            case HttpMethod.PUT:
+                app.put(normalizedPath, handler);
+                break;
+            case HttpMethod.PATCH:
+                app.patch(normalizedPath, handler);
+                break;
+            case HttpMethod.DELETE:
+                app.delete(normalizedPath, handler);
+                break;
+            case HttpMethod.OPTIONS:
+                app.options(normalizedPath, handler);
+                break;
+            case HttpMethod.HEAD:
+                app.on('HEAD', normalizedPath, handler);
+                break;
+            default:
+                app.on(method.toUpperCase(), normalizedPath, handler);
+        }
+    }
+    buildVersionedPaths(globalPrefix, controllerPrefix, routePath, version) {
+        if (version === undefined) {
+            return [
+                this.joinPaths(globalPrefix, this.joinPaths(controllerPrefix, routePath))
+            ];
+        }
+        const versions = Array.isArray(version) ? version : [
+            version
+        ];
+        return versions.map((v)=>{
+            const versionSegment = `/v${v}`;
+            return this.joinPaths(globalPrefix, this.joinPaths(versionSegment, this.joinPaths(controllerPrefix, routePath)));
+        });
+    }
+    joinPaths(prefix, path) {
+        const cleanPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+        const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
+        return `${cleanPrefix}${cleanPath}` || '/';
+    }
+    getControllers() {
+        return [
+            ...this.controllers
+        ];
+    }
+}

package/dist/http/types.d.ts

@@ -0,0 +1,29 @@
+import type { HttpMethod } from '../constants';
+import type { Type } from '../container/types';
+import type { PipeType } from '../registry/types';
+export interface RouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handlerName: string | symbol;
+    version?: number | number[];
+}
+export interface ControllerOptions {
+    prefix?: string;
+    version?: number | number[];
+}
+export interface ControllerMetadata {
+    prefix: string;
+    version?: number | number[];
+}
+export interface ParamMetadata {
+    index: number;
+    type: string;
+    name?: string;
+    pipes?: PipeType[];
+    factory?: (data: unknown, ctx: import('hono').Context) => unknown;
+}
+export interface ControllerRegistration {
+    controller: Type;
+    metadata: ControllerMetadata;
+    routes: RouteMetadata[];
+}

package/dist/http/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import './metadata';
+export { defineMetadata, getMetadata } from './metadata';
+export { VelaFactory } from './factory';
+export { VelaApplication } from './application';
+export { Container, Injectable, Inject, InjectionToken } from './container/index';
+export type { Type, Token, InjectableOptions, ProviderOptions, } from './container/index';
+export { METADATA_KEYS, HttpMethod, ParamType, Scope } from './constants';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, } from './http/index';
+export { Module } from './module/index';
+export type { ModuleOptions, DynamicModule } from './module/index';
+export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, } from './pipeline/index';
+export type { ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, ReflectableDecorator, CreateDecoratorOptions, } from './pipeline/index';
+export type { Constructor, MiddlewareType, GuardType, PipeType, InterceptorType, FilterType, } from './registry/index';
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipeline/index';
+export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './errors/index';
+export type { OnModuleInit, OnApplicationBootstrap, OnModuleDestroy, OnApplicationShutdown, BeforeApplicationShutdown, } from './lifecycle/index';
+export { MetadataRegistry } from './registry/index';
+export { RouteManager } from './http/index';
+export { ModuleLoader } from './module/index';
+export { ComponentManager } from './pipeline/index';

package/dist/index.js

@@ -0,0 +1,26 @@
+import "./metadata.js";
+export { defineMetadata, getMetadata } from "./metadata.js";
+// Factory & Application
+export { VelaFactory } from "./factory.js";
+export { VelaApplication } from "./application.js";
+// DI Container
+export { Container, Injectable, Inject, InjectionToken } from "./container/index.js";
+// Constants
+export { METADATA_KEYS, HttpMethod, ParamType, Scope } from "./constants.js";
+// HTTP Decorators
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator } from "./http/index.js";
+// Module
+export { Module } from "./module/index.js";
+// Pipeline Decorators
+export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/index.js";
+// Built-in Pipes
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipeline/index.js";
+// Errors
+export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException } from "./errors/index.js";
+// Registry (for advanced usage)
+export { MetadataRegistry } from "./registry/index.js";
+// Module internals (for @velajs/testing and advanced usage)
+export { RouteManager } from "./http/index.js";
+export { ModuleLoader } from "./module/index.js";
+// Component Manager (for advanced usage)
+export { ComponentManager } from "./pipeline/index.js";

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,20 @@
+export interface OnModuleInit {
+    onModuleInit(): void | Promise<void>;
+}
+export interface OnApplicationBootstrap {
+    onApplicationBootstrap(): void | Promise<void>;
+}
+export interface OnModuleDestroy {
+    onModuleDestroy(): void | Promise<void>;
+}
+export interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): void | Promise<void>;
+}
+export interface BeforeApplicationShutdown {
+    beforeApplicationShutdown(signal?: string): void | Promise<void>;
+}
+export declare function hasOnModuleInit(instance: unknown): instance is OnModuleInit;
+export declare function hasOnApplicationBootstrap(instance: unknown): instance is OnApplicationBootstrap;
+export declare function hasOnModuleDestroy(instance: unknown): instance is OnModuleDestroy;
+export declare function hasBeforeApplicationShutdown(instance: unknown): instance is BeforeApplicationShutdown;
+export declare function hasOnApplicationShutdown(instance: unknown): instance is OnApplicationShutdown;

package/dist/lifecycle/index.js

@@ -0,0 +1,15 @@
+export function hasOnModuleInit(instance) {
+    return instance !== null && typeof instance === 'object' && typeof instance.onModuleInit === 'function';
+}
+export function hasOnApplicationBootstrap(instance) {
+    return instance !== null && typeof instance === 'object' && typeof instance.onApplicationBootstrap === 'function';
+}
+export function hasOnModuleDestroy(instance) {
+    return instance !== null && typeof instance === 'object' && typeof instance.onModuleDestroy === 'function';
+}
+export function hasBeforeApplicationShutdown(instance) {
+    return instance !== null && typeof instance === 'object' && typeof instance.beforeApplicationShutdown === 'function';
+}
+export function hasOnApplicationShutdown(instance) {
+    return instance !== null && typeof instance === 'object' && typeof instance.onApplicationShutdown === 'function';
+}

package/dist/metadata.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    namespace Reflect {
+        function defineMetadata(key: string, value: unknown, target: object, propertyKey?: string | symbol): void;
+        function getMetadata(key: string, target: object, propertyKey?: string | symbol): unknown;
+        function getOwnMetadata(key: string, target: object, propertyKey?: string | symbol): unknown;
+        function metadata(key: string, value: unknown): (target: object, propertyKey?: string | symbol) => void;
+    }
+}
+export declare function defineMetadata(key: string, value: unknown, target: object, propertyKey?: string | symbol): void;
+export declare function getMetadata(key: string, target: object, propertyKey?: string | symbol): unknown;

package/dist/metadata.js

@@ -0,0 +1,29 @@
+// Lightweight metadata store — replaces the `reflect-metadata` npm package.
+// All custom vela:* keys go through defineMetadata/getMetadata.
+// The Reflect.metadata polyfill keeps SWC's auto-emitted design:paramtypes working.
+const store = new WeakMap();
+function compositeKey(key, prop) {
+    return prop !== undefined ? `${key}\0${String(prop)}` : key;
+}
+export function defineMetadata(key, value, target, propertyKey) {
+    let map = store.get(target);
+    if (!map) {
+        map = new Map();
+        store.set(target, map);
+    }
+    map.set(compositeKey(key, propertyKey), value);
+}
+export function getMetadata(key, target, propertyKey) {
+    return store.get(target)?.get(compositeKey(key, propertyKey));
+}
+// Minimal Reflect polyfill so the compiler's `Reflect.metadata(...)` calls work.
+if (typeof Reflect.defineMetadata !== 'function') {
+    Reflect.defineMetadata = defineMetadata;
+    Reflect.getMetadata = getMetadata;
+    Reflect.getOwnMetadata = getMetadata;
+    Reflect.metadata = (key, value)=>{
+        return (target, propertyKey)=>{
+            defineMetadata(key, value, target, propertyKey);
+        };
+    };
+}

package/dist/module/decorators.d.ts

@@ -0,0 +1,5 @@
+import type { Constructor } from '../registry/types';
+import type { ModuleMetadata, ModuleOptions } from './types';
+export declare function Module(options?: ModuleOptions): ClassDecorator;
+export declare function isModule(target: Constructor): boolean;
+export declare function getModuleMetadata(target: Constructor): ModuleMetadata | undefined;

package/dist/module/decorators.js

@@ -0,0 +1,32 @@
+import { METADATA_KEYS } from "../constants.js";
+import { getMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+export function Module(options = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return (target)=>{
+        MetadataRegistry.setModuleOptions(target, {
+            imports: options.imports,
+            providers: options.providers,
+            controllers: options.controllers,
+            exports: options.exports
+        });
+    };
+}
+export function isModule(target) {
+    return MetadataRegistry.getModuleOptions(target) !== undefined || getMetadata(METADATA_KEYS.MODULE, target) === true;
+}
+export function getModuleMetadata(target) {
+    if (!isModule(target)) {
+        return undefined;
+    }
+    const options = MetadataRegistry.getModuleOptions(target);
+    if (!options) {
+        return undefined;
+    }
+    return {
+        providers: options.providers ?? [],
+        controllers: options.controllers ?? [],
+        imports: options.imports ?? [],
+        exports: options.exports ?? []
+    };
+}

package/dist/module/index.d.ts

@@ -0,0 +1,3 @@
+export { Module, isModule, getModuleMetadata } from './decorators';
+export { ModuleLoader } from './module-loader';
+export type { ModuleOptions, ModuleMetadata, DynamicModule } from './types';

package/dist/module/index.js

@@ -0,0 +1,2 @@
+export { Module, isModule, getModuleMetadata } from "./decorators.js";
+export { ModuleLoader } from "./module-loader.js";

package/dist/module/module-loader.d.ts

@@ -0,0 +1,20 @@
+import type { Container } from '../container/container';
+import type { Token, Type } from '../container/types';
+import type { RouteManager } from '../http/route.manager';
+export declare class ModuleLoader {
+    private container;
+    private router;
+    private processedModules;
+    private processingStack;
+    private collectedControllers;
+    private registeredProviders;
+    private moduleExportsCache;
+    constructor(container: Container, router: RouteManager);
+    load(rootModule: Type): void;
+    private processModule;
+    private registerProvider;
+    private buildExportSet;
+    getControllers(): Type[];
+    getRegisteredProviders(): Token[];
+    resolveAllInstances(): unknown[];
+}