@velajs/vela 1.0.0 → 1.1.0

package/dist/registry/metadata.registry.js

@@ -1,108 +1,69 @@
+import { getOrCreate, getOrCreateArray, getOrCreateMap } from "./util.js";
+function emptyComponentStore() {
+    return {
+        middleware: new Set(),
+        guard: new Set(),
+        pipe: new Set(),
+        interceptor: new Set(),
+        filter: new Set()
+    };
+}
+function emptyComponentByOwner() {
+    return {
+        middleware: new Map(),
+        guard: new Map(),
+        pipe: new Map(),
+        interceptor: new Map(),
+        filter: new Map()
+    };
+}
 export class MetadataRegistry {
+    // Decoration metadata (set at import time, persists across clear()).
     static routes = new Map();
     static controllers = new Map();
     static controllerOptions = new Map();
     static modules = new Map();
     static parameters = new Map();
-    // 3-level component hierarchy
-    static global = new Map([
-        [
-            'middleware',
-            new Set()
-        ],
-        [
-            'guard',
-            new Set()
-        ],
-        [
-            'pipe',
-            new Set()
-        ],
-        [
-            'interceptor',
-            new Set()
-        ],
-        [
-            'filter',
-            new Set()
-        ]
-    ]);
-    static controller = new Map([
-        [
-            'middleware',
-            new Map()
-        ],
-        [
-            'guard',
-            new Map()
-        ],
-        [
-            'pipe',
-            new Map()
-        ],
-        [
-            'interceptor',
-            new Map()
-        ],
-        [
-            'filter',
-            new Map()
-        ]
-    ]);
-    static handler = new Map([
-        [
-            'middleware',
-            new Map()
-        ],
-        [
-            'guard',
-            new Map()
-        ],
-        [
-            'pipe',
-            new Map()
-        ],
-        [
-            'interceptor',
-            new Map()
-        ],
-        [
-            'filter',
-            new Map()
-        ]
-    ]);
-    // DI metadata
     static injectables = new Set();
     static scopes = new Map();
     static injectTokens = new Map();
-    // HTTP handler metadata
     static handlerHttpMeta = new Map();
-    // Exception filter types
     static catchTypes = new Map();
-    // Route versions
     static routeVersions = new Map();
-    // Custom metadata (SetMetadata)
-    static customClassMeta = new Map();
-    static customHandlerMeta = new Map();
+    // Free-form key→value class & handler meta. Backs:
+    //   - @SetMetadata (custom user keys)
+    //   - feature decorators (@Cron, @OnEvent, @ApiDoc, …)
+    //   - the SWC shim (Reflect.metadata's design:* keys)
+    //   - external Reflect.defineMetadata / Reflect.getMetadata calls.
+    static classMeta = new Map();
+    static handlerMeta = new Map();
+    // Component decoration (set by @UseGuards/@UsePipes/etc. at decoration time).
+    static controllerComponents = emptyComponentByOwner();
+    static handlerComponents = {
+        middleware: new Map(),
+        guard: new Map(),
+        pipe: new Map(),
+        interceptor: new Map(),
+        filter: new Map()
+    };
+    // Global components — app-time state (cleared by clear()).
+    static globalComponents = emptyComponentStore();
     // Routes
     static getRoutes(controller) {
-        return this.routes.get(controller) || [];
+        return this.routes.get(controller) ?? [];
     }
     static addRoute(controller, route) {
-        if (!this.routes.has(controller)) {
-            this.routes.set(controller, []);
-        }
-        this.routes.get(controller).push(route);
+        getOrCreateArray(this.routes, controller).push(route);
     }
     // Controllers
     static getControllerPath(controller) {
-        return this.controllers.get(controller) || '';
+        return this.controllers.get(controller) ?? '';
     }
     static setControllerPath(controller, path) {
         this.controllers.set(controller, path);
     }
     static getControllerOptions(controller) {
-        return this.controllerOptions.get(controller) || {};
+        return this.controllerOptions.get(controller) ?? {};
     }
     static setControllerOptions(controller, options) {
         this.controllerOptions.set(controller, options);
@@ -116,53 +77,37 @@ export class MetadataRegistry {
     }
     // Parameters
     static getParameters(controller) {
-        return this.parameters.get(controller) || new Map();
+        return this.parameters.get(controller) ?? new Map();
     }
     static addParameter(controller, methodName, param) {
-        if (!this.parameters.has(controller)) {
-            this.parameters.set(controller, new Map());
-        }
-        const methodParams = this.parameters.get(controller);
-        if (!methodParams.has(methodName)) {
-            methodParams.set(methodName, []);
-        }
-        methodParams.get(methodName).push(param);
+        const methodMap = getOrCreateMap(this.parameters, controller);
+        getOrCreateArray(methodMap, methodName).push(param);
     }
-    // Component registration — 3 levels
+    // Component registration — global
     static registerGlobal(type, component) {
-        this.global.get(type).add(component);
+        this.globalComponents[type].add(component);
     }
     static getGlobal(type) {
-        return this.global.get(type);
+        return this.globalComponents[type];
     }
+    // Component registration — controller-level
     static registerController(type, controller, component) {
-        const typeMap = this.controller.get(type);
-        if (!typeMap.has(controller)) {
-            typeMap.set(controller, []);
-        }
-        typeMap.get(controller).push(component);
+        const map = this.controllerComponents[type];
+        getOrCreateArray(map, controller).push(component);
     }
     static getController(type, controller) {
-        const typeMap = this.controller.get(type);
-        return typeMap.get(controller) || [];
+        const map = this.controllerComponents[type];
+        return map.get(controller) ?? [];
     }
+    // Component registration — handler-level
     static registerHandler(type, controller, methodName, component) {
-        const typeMap = this.handler.get(type);
-        let methodMap = typeMap.get(controller);
-        if (!methodMap) {
-            methodMap = new Map();
-            typeMap.set(controller, methodMap);
-        }
-        let components = methodMap.get(methodName);
-        if (!components) {
-            components = [];
-            methodMap.set(methodName, components);
-        }
-        components.push(component);
+        const map = this.handlerComponents[type];
+        const methodMap = getOrCreateMap(map, controller);
+        getOrCreateArray(methodMap, methodName).push(component);
     }
     static getHandler(type, controller, methodName) {
-        const typeMap = this.handler.get(type);
-        return typeMap.get(controller)?.get(methodName) ?? [];
+        const map = this.handlerComponents[type];
+        return map.get(controller)?.get(methodName) ?? [];
     }
     // DI metadata
     static markInjectable(target) {
@@ -185,12 +130,8 @@ export class MetadataRegistry {
     }
     // HTTP handler metadata
     static setHandlerHttpMeta(controller, method, meta) {
-        if (!this.handlerHttpMeta.has(controller)) {
-            this.handlerHttpMeta.set(controller, new Map());
-        }
-        const methodMap = this.handlerHttpMeta.get(controller);
+        const methodMap = getOrCreateMap(this.handlerHttpMeta, controller);
         const existing = methodMap.get(method) ?? {};
-        // Append-merge responseHeaders
         const merged = {
             ...existing,
             ...meta
@@ -218,79 +159,112 @@ export class MetadataRegistry {
     }
     // Route versions
     static setRouteVersion(controller, method, version) {
-        if (!this.routeVersions.has(controller)) {
-            this.routeVersions.set(controller, new Map());
-        }
-        this.routeVersions.get(controller).set(method, version);
+        getOrCreateMap(this.routeVersions, controller).set(method, version);
     }
     static getRouteVersion(controller, method) {
         return this.routeVersions.get(controller)?.get(method);
     }
-    // Custom metadata (SetMetadata)
+    // Custom class/handler metadata. One slot per (target, key) for class-level,
+    // (target, handler, key) for handler-level. The same slots back @SetMetadata,
+    // every feature decorator (@Cron, @OnEvent, @ApiDoc, …), the SWC shim, and
+    // external Reflect.defineMetadata calls — one model, one source of truth.
     static setCustomClassMeta(target, key, value) {
-        if (!this.customClassMeta.has(target)) {
-            this.customClassMeta.set(target, new Map());
-        }
-        this.customClassMeta.get(target).set(key, value);
+        getOrCreate(this.classMeta, target, ()=>new Map()).set(key, value);
     }
     static getCustomClassMeta(target, key) {
-        return this.customClassMeta.get(target)?.get(key);
+        return this.classMeta.get(target)?.get(key);
     }
     static getCustomClassMetaAll(target) {
-        return this.customClassMeta.get(target);
+        return this.classMeta.get(target);
     }
     static setCustomHandlerMeta(target, handler, key, value) {
-        if (!this.customHandlerMeta.has(target)) {
-            this.customHandlerMeta.set(target, new Map());
-        }
-        const handlerMap = this.customHandlerMeta.get(target);
-        if (!handlerMap.has(handler)) {
-            handlerMap.set(handler, new Map());
-        }
-        handlerMap.get(handler).set(key, value);
+        const byHandler = getOrCreate(this.handlerMeta, target, ()=>new Map());
+        getOrCreate(byHandler, handler, ()=>new Map()).set(key, value);
     }
     static getCustomHandlerMeta(target, handler, key) {
-        return this.customHandlerMeta.get(target)?.get(handler)?.get(key);
+        return this.handlerMeta.get(target)?.get(handler)?.get(key);
     }
     static getCustomHandlerMetaAll(target, handler) {
-        return this.customHandlerMeta.get(target)?.get(handler);
+        return this.handlerMeta.get(target)?.get(handler);
+    }
+    // Append helpers — for stackable metadata like @Cron / @Interval / @OnEvent / @ApiResponse.
+    static appendCustomClassMeta(target, key, item) {
+        const list = this.getCustomClassMeta(target, key) ?? [];
+        list.push(item);
+        this.setCustomClassMeta(target, key, list);
+    }
+    static appendCustomHandlerMeta(target, handler, key, item) {
+        const list = this.getCustomHandlerMeta(target, handler, key) ?? [];
+        list.push(item);
+        this.setCustomHandlerMeta(target, handler, key, list);
+    }
+    // Reflect-style API — same storage as the typed setters above. Lets external
+    // code (and the SWC shim's Reflect.metadata polyfill) write/read uniformly.
+    static setReflectMetadata(target, key, value, propertyKey) {
+        if (propertyKey !== undefined) {
+            this.setCustomHandlerMeta(target, propertyKey, key, value);
+        } else {
+            this.setCustomClassMeta(target, key, value);
+        }
+    }
+    static getReflectMetadata(target, key, propertyKey) {
+        if (propertyKey !== undefined) {
+            return this.getCustomHandlerMeta(target, propertyKey, key);
+        }
+        return this.getCustomClassMeta(target, key);
+    }
+    // SWC-emitted design:paramtypes — class-level for constructors, handler-level for methods.
+    static getParamTypes(target, propertyKey) {
+        return this.getReflectMetadata(target, 'design:paramtypes', propertyKey);
     }
     // Propagate all controller-level components from one class to another.
-    // Used by ModuleLoader to apply module-level decorators to every controller.
     static propagateControllerComponents(from, to) {
-        for (const [, typeMap] of this.controller.entries()){
-            const components = typeMap.get(from);
+        for (const type of [
+            'middleware',
+            'guard',
+            'pipe',
+            'interceptor',
+            'filter'
+        ]){
+            const map = this.controllerComponents[type];
+            const components = map.get(from);
             if (components && components.length > 0) {
-                if (!typeMap.has(to)) {
-                    typeMap.set(to, []);
-                }
-                typeMap.get(to).push(...components);
+                const target = getOrCreateArray(map, to);
+                target.push(...components);
             }
         }
     }
-    // Clear all (for testing)
+    // Clear app-time state. Decoration metadata persists — once a class is
+    // decorated, that fact is permanent for the lifetime of the process.
     static clear() {
+        this.globalComponents = emptyComponentStore();
+    }
+    // Full reset, including decoration metadata. Used in framework-internal scenarios.
+    static reset() {
         this.routes.clear();
         this.controllers.clear();
         this.controllerOptions.clear();
         this.modules.clear();
         this.parameters.clear();
-        for (const set of this.global.values()){
-            set.clear();
-        }
-        for (const map of this.controller.values()){
-            map.clear();
-        }
-        for (const map of this.handler.values()){
-            map.clear();
-        }
         this.injectables.clear();
         this.scopes.clear();
         this.injectTokens.clear();
         this.handlerHttpMeta.clear();
         this.catchTypes.clear();
         this.routeVersions.clear();
-        this.customClassMeta.clear();
-        this.customHandlerMeta.clear();
+        this.classMeta.clear();
+        this.handlerMeta.clear();
+        for (const type of [
+            'middleware',
+            'guard',
+            'pipe',
+            'interceptor',
+            'filter'
+        ]){
+            this.controllerComponents[type].clear();
+            this.handlerComponents[type].clear();
+        }
+        this.globalComponents = emptyComponentStore();
+    // reflectMeta is a WeakMap — entries die with their targets.
     }
 }

package/dist/registry/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizePath(path: string): string;
+export declare function joinPaths(prefix: string, path: string): string;
+export declare function toOpenApiPath(path: string): string;

package/dist/registry/paths.js

@@ -0,0 +1,15 @@
+// Single home for path manipulation. Used by route building, openapi docs,
+// and decorator metadata.
+export function normalizePath(path) {
+    if (!path) return path;
+    return path.startsWith('/') ? path : `/${path}`;
+}
+export function joinPaths(prefix, path) {
+    const cleanPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
+    return `${cleanPrefix}${cleanPath}` || '/';
+}
+// Convert ':id' Hono syntax to '{id}' OpenAPI syntax.
+export function toOpenApiPath(path) {
+    return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+}

package/dist/registry/types.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from 'hono';
 import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
-export type Type<T = any> = new (...args: any[]) => T;
-export type Constructor = Function;
+import type { Constructor, ForwardRef, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
+export type { Constructor, ForwardRef, InjectionToken, ProviderOptions, Token, Type };
 export type ComponentType = 'middleware' | 'guard' | 'pipe' | 'interceptor' | 'filter';
 export type MiddlewareType = Type<NestMiddleware> | NestMiddleware;
 export type GuardType = Type<CanActivate> | CanActivate;
@@ -37,21 +37,31 @@ export interface HttpHandlerMeta {
         statusCode: number;
     };
 }
+export type ModuleImport = Type | DynamicModule | ForwardRef;
+export interface AsyncModuleOptions<T = unknown> {
+    imports?: ModuleImport[];
+    useFactory: (...args: any[]) => T | Promise<T>;
+    inject?: Token[];
+}
+export interface DynamicModule {
+    module: Type;
+    imports?: ModuleImport[];
+    providers?: Array<Type | ProviderOptions>;
+    controllers?: Type[];
+    exports?: Array<Type | InjectionToken>;
+    global?: boolean;
+}
 export interface ModuleOptions {
-    imports?: unknown[];
     providers?: Array<Type | ProviderOptions>;
     controllers?: Type[];
-    exports?: Array<Type | InjectionTokenLike>;
+    imports?: ModuleImport[];
+    exports?: Array<Type | InjectionToken>;
     isGlobal?: boolean;
 }
-export interface InjectionTokenLike {
-    toString(): string;
-}
-export interface ProviderOptions<T = unknown> {
-    token?: unknown;
-    scope?: string;
-    useValue?: T;
-    useFactory?: (...args: unknown[]) => T | Promise<T>;
-    inject?: unknown[];
-    useExisting?: unknown;
+export interface ModuleMetadata {
+    providers: Array<Type | ProviderOptions>;
+    controllers: Type[];
+    imports: ModuleImport[];
+    exports: Array<Type | InjectionToken>;
+    isGlobal: boolean;
 }

package/dist/registry/types.js

@@ -1,2 +1 @@
-// Forward-compatible with ProviderOptions
 export { };

package/dist/registry/util.d.ts

@@ -0,0 +1,3 @@
+export declare function getOrCreate<K, V>(map: Map<K, V>, key: K, factory: () => V): V;
+export declare const getOrCreateMap: <K, NK, NV>(map: Map<K, Map<NK, NV>>, key: K) => Map<NK, NV>;
+export declare const getOrCreateArray: <K, V>(map: Map<K, V[]>, key: K) => V[];

package/dist/registry/util.js

@@ -0,0 +1,8 @@
+// Single map.get + optional set. Replaces `map.has(key) || map.set(key, …); map.get(key)!` patterns.
+export function getOrCreate(map, key, factory) {
+    let v = map.get(key);
+    if (v === undefined) map.set(key, v = factory());
+    return v;
+}
+export const getOrCreateMap = (map, key)=>getOrCreate(map, key, ()=>new Map());
+export const getOrCreateArray = (map, key)=>getOrCreate(map, key, ()=>[]);

package/dist/schedule/schedule.decorators.js

@@ -1,21 +1,18 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
 export function Cron(expression) {
     return (target, propertyKey)=>{
-        const existing = Reflect.getMetadata(CRON_METADATA, target.constructor) ?? [];
-        existing.push({
+        MetadataRegistry.appendCustomClassMeta(target.constructor, CRON_METADATA, {
             expression,
             methodName: String(propertyKey)
         });
-        Reflect.defineMetadata(CRON_METADATA, existing, target.constructor);
     };
 }
 export function Interval(ms) {
     return (target, propertyKey)=>{
-        const existing = Reflect.getMetadata(INTERVAL_METADATA, target.constructor) ?? [];
-        existing.push({
+        MetadataRegistry.appendCustomClassMeta(target.constructor, INTERVAL_METADATA, {
             ms,
             methodName: String(propertyKey)
         });
-        Reflect.defineMetadata(INTERVAL_METADATA, existing, target.constructor);
     };
 }

package/dist/schedule/schedule.registry.js

@@ -14,6 +14,7 @@ function _ts_param(paramIndex, decorator) {
 }
 import { Injectable, Inject } from "../container/index.js";
 import { Container } from "../container/container.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
 export class ScheduleRegistry {
     container;
@@ -26,8 +27,8 @@ export class ScheduleRegistry {
         const tokens = this.container.getTokens();
         for (const token of tokens){
             if (typeof token !== 'function') continue;
-            const cronMeta = Reflect.getMetadata(CRON_METADATA, token);
-            const intervalMeta = Reflect.getMetadata(INTERVAL_METADATA, token);
+            const cronMeta = MetadataRegistry.getCustomClassMeta(token, CRON_METADATA);
+            const intervalMeta = MetadataRegistry.getCustomClassMeta(token, INTERVAL_METADATA);
             if (!cronMeta && !intervalMeta) continue;
             let instance;
             try {

package/dist/throttler/throttler.decorators.d.ts

@@ -1,3 +1,3 @@
 import type { ThrottleConfig } from './throttler.types';
-export declare const Throttle: (config: ThrottleConfig) => (target: Function | object, propertyKey?: string | symbol) => void;
-export declare const SkipThrottle: () => (target: Function | object, propertyKey?: string | symbol) => void;
+export declare const Throttle: (config: ThrottleConfig) => (target: object, propertyKey?: string | symbol) => void;
+export declare const SkipThrottle: () => (target: object, propertyKey?: string | symbol) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
+    },
     "./streaming": {
       "types": "./dist/streaming/index.d.ts",
       "import": "./dist/streaming/index.js"
@@ -56,14 +60,6 @@
   "dependencies": {
     "hono": "^4"
   },
-  "peerDependencies": {
-    "@velajs/crud": ">=0.1.0"
-  },
-  "peerDependenciesMeta": {
-    "@velajs/crud": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@swc/cli": "^0.8.0",
     "@swc/core": "^1.15.11",

package/dist/testing/index.d.ts

@@ -1,2 +0,0 @@
-export { Test, TestingModuleBuilder, OverrideBy } from './testing.builder';
-export { TestingModule } from './testing.module';

package/dist/testing/index.js

@@ -1,2 +0,0 @@
-export { Test, TestingModuleBuilder, OverrideBy } from "./testing.builder.js";
-export { TestingModule } from "./testing.module.js";

package/dist/testing/testing.builder.d.ts

@@ -1,29 +0,0 @@
-import type { Token, Type } from '../container/types';
-import type { ModuleOptions } from '../module/types';
-import { TestingModule } from './testing.module';
-export declare class OverrideBy {
-    private readonly builder;
-    private readonly token;
-    constructor(builder: TestingModuleBuilder, token: Token);
-    useValue(value: unknown): TestingModuleBuilder;
-    useClass(cls: Type): TestingModuleBuilder;
-    useFactory(options: {
-        factory: (...args: unknown[]) => unknown;
-        inject?: Token[];
-    }): TestingModuleBuilder;
-}
-export declare class TestingModuleBuilder {
-    private readonly metadata;
-    private overrides;
-    constructor(metadata: ModuleOptions);
-    overrideProvider(token: Token): OverrideBy;
-    overrideGuard(guard: Type): OverrideBy;
-    overridePipe(pipe: Type): OverrideBy;
-    overrideInterceptor(interceptor: Type): OverrideBy;
-    overrideFilter(filter: Type): OverrideBy;
-    private addOverride;
-    compile(): Promise<TestingModule>;
-}
-export declare class Test {
-    static createTestingModule(metadata: ModuleOptions): TestingModuleBuilder;
-}