@velajs/vela 1.9.0 → 1.12.0

package/dist/pipeline/pipeline-runner.js

@@ -0,0 +1,40 @@
+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/types.d.ts

@@ -11,16 +11,33 @@ export interface HttpArgumentsHost {
     getRequest<T = Request>(): T;
     getResponse<T = Context>(): T;
 }
+/**
+ * WebSocket-specific arguments host returned by `ExecutionContext.switchToWs()`.
+ * Populated by `@velajs/vela/websocket` when a gateway message is dispatched.
+ *
+ * - `getClient()` — the connected socket (`WsClient`)
+ * - `getData()` — the inbound message payload (the envelope's `data`)
+ * - `getPattern()` — the subscribed event name that matched
+ */
+export interface WsArgumentsHost {
+    getClient<T = unknown>(): T;
+    getData<T = unknown>(): T;
+    getPattern<T = string>(): T;
+}
+/** The transport a component is executing under. `'http'` for routes, `'ws'` for gateway messages. */
+export type ContextType = 'http' | 'ws';
 export interface ExecutionContext {
-    getType<T extends string = 'http'>(): T;
+    getType<T extends string = ContextType>(): T;
     getClass(): Type;
     getHandler(): string | symbol;
-    /** Returns the Hono `Context` directly. */
+    /** Returns the Hono `Context` directly. Throws on a WebSocket context. */
     getContext<T = Context>(): T;
-    /** Shorthand for `switchToHttp().getRequest()` — returns the Web `Request`. */
+    /** Shorthand for `switchToHttp().getRequest()` — returns the Web `Request`. Throws on a WebSocket context. */
     getRequest(): Request;
-    /** Switch to the HTTP arguments host for NestJS-style `getRequest()` / `getResponse()` access. */
+    /** Switch to the HTTP arguments host. Throws on a WebSocket context. */
     switchToHttp(): HttpArgumentsHost;
+    /** Switch to the WebSocket arguments host. Throws on an HTTP context. */
+    switchToWs(): WsArgumentsHost;
 }
 export interface CanActivate {
     canActivate(context: ExecutionContext): boolean | Promise<boolean>;

package/dist/registry/metadata.registry.d.ts

@@ -5,22 +5,23 @@ export interface ControllerOptions {
     version?: number | number[];
 }
 export declare class MetadataRegistry {
-    private static readonly routes;
-    private static readonly controllers;
-    private static readonly controllerOptions;
-    private static readonly modules;
-    private static readonly parameters;
-    private static readonly injectables;
-    private static readonly scopes;
-    private static readonly injectTokens;
-    private static readonly handlerHttpMeta;
-    private static readonly catchTypes;
-    private static readonly routeVersions;
-    private static readonly classMeta;
-    private static readonly handlerMeta;
-    private static readonly controllerComponents;
-    private static readonly handlerComponents;
-    private static globalComponents;
+    private static get routes();
+    private static get controllers();
+    private static get controllerOptions();
+    private static get modules();
+    private static get parameters();
+    private static get injectables();
+    private static get scopes();
+    private static get injectTokens();
+    private static get handlerHttpMeta();
+    private static get catchTypes();
+    private static get routeVersions();
+    private static get classMeta();
+    private static get handlerMeta();
+    private static get classMetaIndex();
+    private static get handlerMetaIndex();
+    private static get controllerComponents();
+    private static get handlerComponents();
     static getRoutes(controller: Constructor): RouteDefinition[];
     static addRoute(controller: Constructor, route: RouteDefinition): void;
     static getControllerPath(controller: Constructor): string;
@@ -31,8 +32,6 @@ export declare class MetadataRegistry {
     static setModuleOptions(module: Constructor, options: ModuleOptions): void;
     static getParameters(controller: Constructor): Map<string | symbol, ParameterMetadata[]>;
     static addParameter(controller: Constructor, methodName: string | symbol, param: ParameterMetadata): void;
-    static registerGlobal<T extends ComponentType>(type: T, component: ComponentTypeMap[T]): void;
-    static getGlobal<T extends ComponentType>(type: T): Set<ComponentTypeMap[T]>;
     static registerController<T extends ComponentType>(type: T, controller: Constructor, component: ComponentTypeMap[T]): void;
     static getController<T extends ComponentType>(type: T, controller: Constructor): ComponentTypeMap[T][];
     static registerHandler<T extends ComponentType>(type: T, controller: Constructor, methodName: string | symbol, component: ComponentTypeMap[T]): void;
@@ -58,6 +57,13 @@ export declare class MetadataRegistry {
     static getCustomHandlerMetaAll(target: object, handler: string | symbol): Map<string, unknown> | undefined;
     static appendCustomClassMeta<T>(target: object, key: string, item: T): void;
     static appendCustomHandlerMeta<T>(target: object, handler: string | symbol, key: string, item: T): void;
+    static getClassesWithClassMeta(key: string): ReadonlySet<object>;
+    static getClassesWithHandlerMeta(key: string): ReadonlySet<object>;
+    /** Every (handler, value) pair on `target` carrying metadata under `key`. */
+    static getHandlersWithMeta(target: object, key: string): Array<{
+        handler: string | symbol;
+        value: unknown;
+    }>;
     static setReflectMetadata(target: object, key: string, value: unknown, propertyKey?: string | symbol): void;
     static getReflectMetadata<T = unknown>(target: object, key: string, propertyKey?: string | symbol): T | undefined;
     static getParamTypes(target: object, propertyKey?: string | symbol): unknown[] | undefined;

package/dist/registry/metadata.registry.js

@@ -1,13 +1,4 @@
 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(),
@@ -17,37 +8,107 @@ function emptyComponentByOwner() {
         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();
-    static injectables = new Set();
-    static scopes = new Map();
-    static injectTokens = new Map();
-    static handlerHttpMeta = new Map();
-    static catchTypes = new Map();
-    static routeVersions = 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()
+function createRegistryState() {
+    return {
+        routes: new Map(),
+        controllers: new Map(),
+        controllerOptions: new Map(),
+        modules: new Map(),
+        parameters: new Map(),
+        injectables: new Set(),
+        scopes: new Map(),
+        injectTokens: new Map(),
+        handlerHttpMeta: new Map(),
+        catchTypes: new Map(),
+        routeVersions: new Map(),
+        classMeta: new Map(),
+        handlerMeta: new Map(),
+        classMetaIndex: new Map(),
+        handlerMetaIndex: new Map(),
+        controllerComponents: emptyComponentByOwner(),
+        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();
+}
+// HMR-safe: anchor ALL backing state on `globalThis` so a Vite dev re-eval of
+// this module reuses the SAME maps that classes were already decorated against.
+// Without this, re-eval creates fresh empty statics → split-brain (lost routes,
+// spurious "not @Injectable" warnings, duplicated global components). The
+// versioned symbol avoids collisions across framework major versions in one
+// process. `globalThis` + `Symbol.for` exist on every target runtime; no node:*.
+const REGISTRY_STATE_KEY = Symbol.for('vela:registry:v1');
+// Shared empty result for index misses — avoids allocating per lookup.
+const EMPTY_TARGET_SET = new Set();
+function registryState() {
+    const g = globalThis;
+    const state = g[REGISTRY_STATE_KEY] ??= createRegistryState();
+    // Backfill fields added after the v1 state shape was first anchored: a state
+    // created by an older copy of this module (dist/src coexistence in tests,
+    // mixed package versions in one process) must not crash newer readers.
+    state.classMetaIndex ??= new Map();
+    state.handlerMetaIndex ??= new Map();
+    return state;
+}
+export class MetadataRegistry {
+    // Every field is a getter over the globalThis-anchored state (registryState).
+    // Method bodies keep using `this.<field>`; the getter returns the live map so
+    // `.set`/`.get`/`.clear` mutate the shared state.
+    static get routes() {
+        return registryState().routes;
+    }
+    static get controllers() {
+        return registryState().controllers;
+    }
+    static get controllerOptions() {
+        return registryState().controllerOptions;
+    }
+    static get modules() {
+        return registryState().modules;
+    }
+    static get parameters() {
+        return registryState().parameters;
+    }
+    static get injectables() {
+        return registryState().injectables;
+    }
+    static get scopes() {
+        return registryState().scopes;
+    }
+    static get injectTokens() {
+        return registryState().injectTokens;
+    }
+    static get handlerHttpMeta() {
+        return registryState().handlerHttpMeta;
+    }
+    static get catchTypes() {
+        return registryState().catchTypes;
+    }
+    static get routeVersions() {
+        return registryState().routeVersions;
+    }
+    static get classMeta() {
+        return registryState().classMeta;
+    }
+    static get handlerMeta() {
+        return registryState().handlerMeta;
+    }
+    static get classMetaIndex() {
+        return registryState().classMetaIndex;
+    }
+    static get handlerMetaIndex() {
+        return registryState().handlerMetaIndex;
+    }
+    static get controllerComponents() {
+        return registryState().controllerComponents;
+    }
+    static get handlerComponents() {
+        return registryState().handlerComponents;
+    }
     // Routes
     static getRoutes(controller) {
         return this.routes.get(controller) ?? [];
@@ -83,14 +144,9 @@ export class MetadataRegistry {
         const methodMap = getOrCreateMap(this.parameters, controller);
         getOrCreateArray(methodMap, methodName).push(param);
     }
-    // Component registration — global
-    static registerGlobal(type, component) {
-        this.globalComponents[type].add(component);
-    }
-    static getGlobal(type) {
-        return this.globalComponents[type];
-    }
-    // Component registration — controller-level
+    // Component registration — controller-level. (There is deliberately NO
+    // global tier here: app-wide components live on the per-app RouteManager,
+    // one source, never process-global state.)
     static registerController(type, controller, component) {
         const map = this.controllerComponents[type];
         getOrCreateArray(map, controller).push(component);
@@ -170,6 +226,9 @@ export class MetadataRegistry {
     // external Reflect.defineMetadata calls — one model, one source of truth.
     static setCustomClassMeta(target, key, value) {
         getOrCreate(this.classMeta, target, ()=>new Map()).set(key, value);
+        if (!key.startsWith('design:')) {
+            getOrCreate(this.classMetaIndex, key, ()=>new Set()).add(target);
+        }
     }
     static getCustomClassMeta(target, key) {
         return this.classMeta.get(target)?.get(key);
@@ -180,6 +239,9 @@ export class MetadataRegistry {
     static setCustomHandlerMeta(target, handler, key, value) {
         const byHandler = getOrCreate(this.handlerMeta, target, ()=>new Map());
         getOrCreate(byHandler, handler, ()=>new Map()).set(key, value);
+        if (!key.startsWith('design:')) {
+            getOrCreate(this.handlerMetaIndex, key, ()=>new Set()).add(target);
+        }
     }
     static getCustomHandlerMeta(target, handler, key) {
         return this.handlerMeta.get(target)?.get(handler)?.get(key);
@@ -198,6 +260,28 @@ export class MetadataRegistry {
         list.push(item);
         this.setCustomHandlerMeta(target, handler, key, list);
     }
+    // Reverse-index readers — the DiscoveryService seam. Return the constructors
+    // known to carry class-level (resp. handler-level) metadata under `key`.
+    // Callers must still intersect with container-registered tokens: decoration
+    // alone does not make a class a provider.
+    static getClassesWithClassMeta(key) {
+        return this.classMetaIndex.get(key) ?? EMPTY_TARGET_SET;
+    }
+    static getClassesWithHandlerMeta(key) {
+        return this.handlerMetaIndex.get(key) ?? EMPTY_TARGET_SET;
+    }
+    /** Every (handler, value) pair on `target` carrying metadata under `key`. */ static getHandlersWithMeta(target, key) {
+        const byHandler = this.handlerMeta.get(target);
+        if (!byHandler) return [];
+        const out = [];
+        for (const [handler, metaMap] of byHandler){
+            if (metaMap.has(key)) out.push({
+                handler,
+                value: metaMap.get(key)
+            });
+        }
+        return out;
+    }
     // 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) {
@@ -236,8 +320,11 @@ export class MetadataRegistry {
     }
     // Clear app-time state. Decoration metadata persists — once a class is
     // decorated, that fact is permanent for the lifetime of the process.
+    // Currently a no-op: the last piece of app-time registry state (the global
+    // component tier) moved to the per-app RouteManager. Kept because test
+    // suites call it between cases and future app-time state belongs here.
     static clear() {
-        this.globalComponents = emptyComponentStore();
+    // no app-time state to clear
     }
     // Full reset, including decoration metadata. Used in framework-internal scenarios.
     static reset() {
@@ -254,6 +341,8 @@ export class MetadataRegistry {
         this.routeVersions.clear();
         this.classMeta.clear();
         this.handlerMeta.clear();
+        this.classMetaIndex.clear();
+        this.handlerMetaIndex.clear();
         for (const type of [
             'middleware',
             'guard',
@@ -264,6 +353,5 @@ export class MetadataRegistry {
             this.controllerComponents[type].clear();
             this.handlerComponents[type].clear();
         }
-        this.globalComponents = emptyComponentStore();
     }
 }

package/dist/schedule/schedule.module.d.ts

@@ -1,4 +1,9 @@
 import type { DynamicModule } from '../module/types';
+/**
+ * Zero-config module (Tier C): providers live on the `@Module` bag; the
+ * `forRoot()` static is NestJS-parity sugar returning the bare dynamic module
+ * (default key — repeated calls dedup).
+ */
 export declare class ScheduleModule {
     static forRoot(): DynamicModule;
 }

package/dist/schedule/schedule.module.js

@@ -1,15 +1,25 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/decorators.js";
 import { ScheduleRegistry } from "./schedule.registry.js";
 export class ScheduleModule {
     static forRoot() {
-        const providers = [
-            ScheduleRegistry
-        ];
         return {
-            module: ScheduleModule,
-            providers,
-            exports: [
-                ScheduleRegistry
-            ]
+            module: ScheduleModule
         };
     }
 }
+ScheduleModule = _ts_decorate([
+    Module({
+        providers: [
+            ScheduleRegistry
+        ],
+        exports: [
+            ScheduleRegistry
+        ]
+    })
+], ScheduleModule);

package/dist/schedule/schedule.registry.d.ts

@@ -1,4 +1,4 @@
-import { Container } from '../container/container';
+import { DiscoveryService } from '../discovery/discovery.service';
 import type { OnApplicationBootstrap } from '../lifecycle/index';
 export interface RegisteredCronJob {
     expression: string;
@@ -13,10 +13,10 @@ export interface RegisteredIntervalJob {
     target: Function;
 }
 export declare class ScheduleRegistry implements OnApplicationBootstrap {
-    private container;
+    private readonly discovery;
     private cronJobs;
     private intervalJobs;
-    constructor(container: Container);
+    constructor(discovery: DiscoveryService);
     onApplicationBootstrap(): void;
     getCronJobs(): RegisteredCronJob[];
     getIntervalJobs(): RegisteredIntervalJob[];

package/dist/schedule/schedule.registry.js

@@ -13,54 +13,33 @@ 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 { DiscoveryService } from "../discovery/discovery.service.js";
 import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
 export class ScheduleRegistry {
-    container;
+    discovery;
     cronJobs = [];
     intervalJobs = [];
-    constructor(container){
-        this.container = container;
+    constructor(discovery){
+        this.discovery = discovery;
     }
     onApplicationBootstrap() {
-        const tokens = this.container.getTokens();
-        for (const token of tokens){
-            if (typeof token !== 'function') continue;
-            const cronMeta = MetadataRegistry.getCustomClassMeta(token, CRON_METADATA);
-            const intervalMeta = MetadataRegistry.getCustomClassMeta(token, INTERVAL_METADATA);
-            if (!cronMeta && !intervalMeta) continue;
-            let instance;
-            try {
-                instance = this.container.resolve(token);
-            } catch (err) {
-                const mode = this.container.getDiagnostics();
-                if (mode === 'throw') throw err;
-                if (mode === 'log') {
-                    console.warn(`[vela] schedule discovery: cannot resolve ${token.name || String(token)}:`, err);
-                }
-                continue;
-            }
-            if (cronMeta) {
-                for (const { expression, methodName } of cronMeta){
-                    this.cronJobs.push({
-                        expression,
-                        methodName,
-                        instance,
-                        target: token
-                    });
-                }
-            }
-            if (intervalMeta) {
-                for (const { ms, methodName } of intervalMeta){
-                    this.intervalJobs.push({
-                        ms,
-                        methodName,
-                        instance,
-                        target: token
-                    });
-                }
-            }
+        for (const found of this.discovery.methodsWithMeta(CRON_METADATA)){
+            if (!found.class.instance) continue;
+            this.cronJobs.push({
+                expression: found.meta.expression,
+                methodName: String(found.methodName),
+                instance: found.class.instance,
+                target: found.class.metatype
+            });
+        }
+        for (const found of this.discovery.methodsWithMeta(INTERVAL_METADATA)){
+            if (!found.class.instance) continue;
+            this.intervalJobs.push({
+                ms: found.meta.ms,
+                methodName: String(found.methodName),
+                instance: found.class.instance,
+                target: found.class.metatype
+            });
         }
     }
     getCronJobs() {
@@ -76,9 +55,9 @@ export class ScheduleRegistry {
 }
 ScheduleRegistry = _ts_decorate([
     Injectable(),
-    _ts_param(0, Inject(Container)),
+    _ts_param(0, Inject(DiscoveryService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof Container === "undefined" ? Object : Container
+        typeof DiscoveryService === "undefined" ? Object : DiscoveryService
     ])
 ], ScheduleRegistry);

package/dist/schedule-node/schedule-node.module.d.ts

@@ -1,4 +1,9 @@
 import type { DynamicModule } from '../module/types';
+/**
+ * Zero-config module (Tier C): providers live on the `@Module` bag; the
+ * `forRoot()` static is NestJS-parity sugar returning the bare dynamic module
+ * (default key — repeated calls dedup).
+ */
 export declare class ScheduleNodeModule {
     static forRoot(): DynamicModule;
 }

package/dist/schedule-node/schedule-node.module.js

@@ -1,18 +1,28 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/decorators.js";
 import { ScheduleRegistry } from "../schedule/schedule.registry.js";
 import { ScheduleExecutor } from "./schedule.executor.js";
 export class ScheduleNodeModule {
     static forRoot() {
-        const providers = [
-            ScheduleRegistry,
-            ScheduleExecutor
-        ];
         return {
-            module: ScheduleNodeModule,
-            providers,
-            exports: [
-                ScheduleRegistry,
-                ScheduleExecutor
-            ]
+            module: ScheduleNodeModule
         };
     }
 }
+ScheduleNodeModule = _ts_decorate([
+    Module({
+        providers: [
+            ScheduleRegistry,
+            ScheduleExecutor
+        ],
+        exports: [
+            ScheduleRegistry,
+            ScheduleExecutor
+        ]
+    })
+], ScheduleNodeModule);

package/dist/seeder/index.d.ts

@@ -0,0 +1,5 @@
+export { Seeder } from './seeder.decorator';
+export { SeederRegistry } from './seeder.registry';
+export { SeederModule, runSeeders } from './seeder.module';
+export { SEEDER_METADATA } from './seeder.tokens';
+export type { Seeder as ISeeder, SeederMetadata, RegisteredSeeder, SeederResult, } from './seeder.types';

package/dist/seeder/index.js

@@ -0,0 +1,4 @@
+export { Seeder } from "./seeder.decorator.js";
+export { SeederRegistry } from "./seeder.registry.js";
+export { SeederModule, runSeeders } from "./seeder.module.js";
+export { SEEDER_METADATA } from "./seeder.tokens.js";

package/dist/seeder/seeder.decorator.d.ts

@@ -0,0 +1,7 @@
+import type { SeederMetadata } from './seeder.types';
+/**
+ * Mark a class as a seeder. Also marks it `@Injectable()` (singleton) so it only
+ * needs to be listed in a module's providers (or `SeederModule.forRoot({ seeders })`)
+ * to be discovered by {@link SeederRegistry} at bootstrap.
+ */
+export declare function Seeder(options?: SeederMetadata): ClassDecorator;

package/dist/seeder/seeder.decorator.js

@@ -0,0 +1,15 @@
+import { Scope } from "../constants.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { SEEDER_METADATA } from "./seeder.tokens.js";
+/**
+ * Mark a class as a seeder. Also marks it `@Injectable()` (singleton) so it only
+ * needs to be listed in a module's providers (or `SeederModule.forRoot({ seeders })`)
+ * to be discovered by {@link SeederRegistry} at bootstrap.
+ */ export function Seeder(options = {}) {
+    return (target)=>{
+        const ctor = target;
+        MetadataRegistry.markInjectable(ctor);
+        MetadataRegistry.setScope(ctor, Scope.SINGLETON);
+        MetadataRegistry.setCustomClassMeta(target, SEEDER_METADATA, options);
+    };
+}

package/dist/seeder/seeder.module.d.ts

@@ -0,0 +1,16 @@
+import type { VelaApplication } from '../application';
+import type { Type } from '../container/types';
+import type { SeederResult } from './seeder.types';
+export interface SeederModuleOptions {
+    seeders?: Type[];
+}
+declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<SeederModuleOptions, "forRoot", "create", {
+    isGlobal?: boolean;
+}>;
+export declare class SeederModule extends ConfigurableModuleClass {
+}
+/** Convenience runner: resolve the registry from a built app and run all seeders. */
+export declare function runSeeders(app: VelaApplication, options?: {
+    stopOnError?: boolean;
+}): Promise<SeederResult[]>;
+export {};