@velajs/vela 1.19.0 → 1.19.1

package/dist/module/module-loader.js

@@ -1,484 +0,0 @@
-import { Scope } from "../constants.js";
-import { ForwardRef, InjectionToken, ModuleVisibilityError, MultipleProvidersFoundError } from "../container/types.js";
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { getOrCreateArray } from "../registry/util.js";
-import { getModuleMetadata, isModule } from "./decorators.js";
-import { LazyModuleManager } from "./lazy-modules.js";
-import { MiddlewareBuilder } from "./middleware.js";
-const APP_TOKENS = new Set([
-    APP_GUARD,
-    APP_PIPE,
-    APP_INTERCEPTOR,
-    APP_FILTER,
-    APP_MIDDLEWARE
-]);
-const DEFAULT_KEY = "default";
-/**
- * Structural check for `ContributesEntrypoints` on a provider's class —
- * deliberately string-coupled to the interface's method name so the loader
- * does not import from `entrypoint/` (layering).
- */ function declaresEntrypointContributor(provider) {
-    const cls = typeof provider === "function" ? provider : provider.useClass;
-    if (typeof cls !== "function") return false;
-    const proto = cls.prototype;
-    return typeof proto?.collectEntrypoints === "function";
-}
-function isDynamicModule(value) {
-    // TS 4.9+ narrows `'module' in value` so `value.module` is typed `unknown`
-    // — no cast required for the typeof check below.
-    return typeof value === "object" && value !== null && "module" in value && typeof value.module === "function";
-}
-function implementsNestModule(cls) {
-    // `Type.prototype` is `any` — direct property access is type-safe enough.
-    return typeof cls.prototype?.configure === "function";
-}
-function tokenOfProvider(provider) {
-    return typeof provider === "function" ? provider : provider.provide;
-}
-function keyOfImport(entry) {
-    return isDynamicModule(entry) ? entry.key ?? DEFAULT_KEY : DEFAULT_KEY;
-}
-/**
- * `ForwardRef.factory` is typed to return the broader `Token<T>` because the
- * primitive is shared with provider injection. In module-imports position the
- * runtime contract narrows: the factory must yield a module class or a
- * `DynamicModule`. This helper validates the contract AND narrows the type
- * without a structural cast.
- */ function unwrapModuleForwardRef(ref) {
-    const result = ref.factory();
-    if (typeof result === 'function') return result;
-    if (isDynamicModule(result)) return result;
-    throw new Error(`forwardRef in module imports must resolve to a module class or DynamicModule; ` + `got ${typeof result === 'object' ? 'a non-module object' : typeof result}.`);
-}
-export class ModuleLoader {
-    container;
-    router;
-    // class → set of keys already processed (multi-instance dedup is by both)
-    processedModules = new Map();
-    processingStack = new Set();
-    collectedControllers = new Set();
-    registeredProviders = [];
-    // (class, key) → exported tokens
-    moduleExportsCache = new Map();
-    globalExports = new Set();
-    consumerMiddlewareDefinitions = [];
-    appProviderCounter = 0;
-    appProviderTokens = new Map([
-        [
-            APP_GUARD,
-            []
-        ],
-        [
-            APP_PIPE,
-            []
-        ],
-        [
-            APP_INTERCEPTOR,
-            []
-        ],
-        [
-            APP_FILTER,
-            []
-        ],
-        [
-            APP_MIDDLEWARE,
-            []
-        ]
-    ]);
-    // (class, key) → composed moduleId (cached for stable identity within a load)
-    moduleIdByClassKey = new Map();
-    seenModuleIds = new Set();
-    // Lazy (deferred-init) module instances: moduleId → its own tokens in
-    // registration order. Consumed by LazyModuleManager via getLazyGroups().
-    lazyModuleIds = new Set();
-    lazyGroups = new Map();
-    constructor(container, router){
-        this.container = container;
-        this.router = router;
-    }
-    load(rootModule) {
-        this.processModule(rootModule);
-        for (const controller of this.collectedControllers){
-            this.router.registerController(controller);
-        }
-        // Arm the deferred-init seam HERE — at the end of load(), not in
-        // bootstrap() — so every consumer of the loader gets identical lazy
-        // semantics, including hand-rolled bootstrap paths that never call
-        // bootstrap() (@velajs/testing's TestingModuleBuilder.compile builds its
-        // own container). Still after all module-load-time resolutions
-        // (NestModule.configure), so load-time resolution never claims a group.
-        // Registered as a provider so VelaApplication can drive the phase
-        // transitions from any of those paths.
-        const lazyManager = new LazyModuleManager(this.container);
-        for (const group of this.getLazyGroups()){
-            lazyManager.registerGroup(group);
-        }
-        this.container.setLazyHook(lazyManager);
-        this.container.register({
-            provide: LazyModuleManager,
-            useValue: lazyManager
-        });
-    }
-    getModuleId(moduleClass, key) {
-        let perClass = this.moduleIdByClassKey.get(moduleClass);
-        if (perClass) {
-            const cached = perClass.get(key);
-            if (cached) return cached;
-        } else {
-            perClass = new Map();
-            this.moduleIdByClassKey.set(moduleClass, perClass);
-        }
-        const baseName = moduleClass.name || "AnonModule";
-        let id = `${baseName}#${key}`;
-        let counter = 0;
-        // Cross-class name collision (rare): two different classes named identically.
-        // The (class, key) pair identifies us; bump suffix to keep `id` strings unique
-        // in `seenModuleIds` so debug output stays unambiguous.
-        while(this.seenModuleIds.has(id)){
-            id = `${baseName}#${key}~${++counter}`;
-        }
-        this.seenModuleIds.add(id);
-        perClass.set(key, id);
-        return id;
-    }
-    isProcessed(moduleClass, key) {
-        return this.processedModules.get(moduleClass)?.has(key) ?? false;
-    }
-    markProcessed(moduleClass, key) {
-        let keys = this.processedModules.get(moduleClass);
-        if (!keys) {
-            keys = new Set();
-            this.processedModules.set(moduleClass, keys);
-        }
-        keys.add(key);
-    }
-    getCachedExports(moduleClass, key) {
-        return this.moduleExportsCache.get(moduleClass)?.get(key);
-    }
-    cacheExports(moduleClass, key, exports) {
-        let perClass = this.moduleExportsCache.get(moduleClass);
-        if (!perClass) {
-            perClass = new Map();
-            this.moduleExportsCache.set(moduleClass, perClass);
-        }
-        perClass.set(key, exports);
-    }
-    processModule(moduleClassOrDynamic) {
-        let moduleClass;
-        let extraImports = [];
-        let extraControllers = [];
-        let extraProviders = [];
-        let extraExports = [];
-        let key = DEFAULT_KEY;
-        if (isDynamicModule(moduleClassOrDynamic)) {
-            moduleClass = moduleClassOrDynamic.module;
-            extraImports = moduleClassOrDynamic.imports ?? [];
-            extraControllers = moduleClassOrDynamic.controllers ?? [];
-            extraProviders = moduleClassOrDynamic.providers ?? [];
-            extraExports = moduleClassOrDynamic.exports ?? [];
-            key = moduleClassOrDynamic.key ?? DEFAULT_KEY;
-        } else {
-            moduleClass = moduleClassOrDynamic;
-        }
-        if (this.isProcessed(moduleClass, key)) {
-            // Even if already processed, still collect extra controllers from dynamic module
-            for (const controller of extraControllers){
-                this.collectedControllers.add(controller);
-            }
-            return this.getCachedExports(moduleClass, key) ?? new Set();
-        }
-        const stackKey = `${moduleClass.name}#${key}`;
-        if (this.processingStack.has(stackKey)) {
-            const chain = [
-                ...this.processingStack,
-                stackKey
-            ].join(" -> ");
-            throw new Error(`Circular module dependency detected: ${chain}`);
-        }
-        if (!isModule(moduleClass)) {
-            if (isDynamicModule(moduleClassOrDynamic)) {
-                MetadataRegistry.setModuleOptions(moduleClass, {});
-            } else {
-                throw new Error(`${moduleClass.name} is not a module. Add @Module() decorator to the class.`);
-            }
-        }
-        const metadata = getModuleMetadata(moduleClass);
-        if (!metadata) {
-            throw new Error(`Failed to get module metadata for ${moduleClass.name}`);
-        }
-        this.processingStack.add(stackKey);
-        const moduleId = this.getModuleId(moduleClass, key);
-        try {
-            const importedProviders = new Set(this.globalExports);
-            // Determine importedModuleIds eagerly (before recursing) so child
-            // modules can be referenced in our scope's importedModules set.
-            const importedModuleIds = new Set();
-            // Track per-class keys seen in this imports array — emit a loader-time
-            // diagnostic when the same module class appears under both `"default"`
-            // and at least one explicit key (almost always user error).
-            const keysByClassInImports = new Map();
-            const allImports = [
-                ...metadata.imports,
-                ...extraImports
-            ];
-            for (const entry of allImports){
-                const importedModule = entry instanceof ForwardRef ? unwrapModuleForwardRef(entry) : entry;
-                const importedModuleClass = isDynamicModule(importedModule) ? importedModule.module : importedModule;
-                const importedKey = keyOfImport(importedModule);
-                let keys = keysByClassInImports.get(importedModuleClass);
-                if (!keys) {
-                    keys = new Set();
-                    keysByClassInImports.set(importedModuleClass, keys);
-                }
-                keys.add(importedKey);
-                const importedId = this.getModuleId(importedModuleClass, importedKey);
-                importedModuleIds.add(importedId);
-                const importedStackKey = `${importedModuleClass.name}#${importedKey}`;
-                if (entry instanceof ForwardRef && this.processingStack.has(importedStackKey)) {
-                    continue;
-                }
-                const exportedTokens = this.processModule(importedModule);
-                for (const token of exportedTokens){
-                    importedProviders.add(token);
-                }
-            }
-            this.warnOnMixedDefaultAndKeyed(moduleClass.name, keysByClassInImports);
-            const allProviders = [
-                ...metadata.providers,
-                ...extraProviders
-            ];
-            const allControllers = [
-                ...metadata.controllers,
-                ...extraControllers
-            ];
-            const allExports = [
-                ...metadata.exports,
-                ...extraExports
-            ];
-            // Build the ModuleScope BEFORE registering providers so the visibility
-            // check sees the local-provider set as we register.
-            const localProviders = new Set();
-            for (const provider of allProviders){
-                const tk = tokenOfProvider(provider);
-                if (tk !== undefined) localProviders.add(tk);
-            }
-            for (const controller of allControllers){
-                localProviders.add(controller);
-            }
-            // The module class itself can be DI-resolved (NestModule.configure path);
-            // include it in its own scope.
-            localProviders.add(moduleClass);
-            const isGlobal = metadata.isGlobal || isDynamicModule(moduleClassOrDynamic) && moduleClassOrDynamic.global === true;
-            const isLazy = metadata.lazy || isDynamicModule(moduleClassOrDynamic) && moduleClassOrDynamic.lazy === true;
-            this.container.registerScope({
-                moduleId,
-                localProviders,
-                importedModules: importedModuleIds,
-                exportedTokens: new Set(allExports),
-                isGlobal,
-                lazy: isLazy
-            });
-            const lazyTokens = [];
-            let hasEntrypointContributor = false;
-            for (const provider of allProviders){
-                const registered = this.registerProvider(provider, moduleId);
-                if (isLazy && registered !== undefined) {
-                    lazyTokens.push(registered);
-                    hasEntrypointContributor ||= declaresEntrypointContributor(provider);
-                }
-            }
-            for (const controller of allControllers){
-                // Register the controller in its owning module's bucket so its
-                // dependencies resolve from the module's POV (vs `__root__`'s).
-                this.container.register(controller, moduleId);
-                this.collectedControllers.add(controller);
-                if (isLazy) lazyTokens.push(controller);
-            }
-            if (isLazy) {
-                this.lazyModuleIds.add(moduleId);
-                this.lazyGroups.set(moduleId, {
-                    moduleId,
-                    tokens: lazyTokens,
-                    hasEntrypointContributor
-                });
-            }
-            // Propagate module-level Use* decorators (@UseGuards, @UseInterceptors, etc.) to each controller
-            for (const controller of allControllers){
-                MetadataRegistry.propagateControllerComponents(moduleClass, controller);
-            }
-            this.markProcessed(moduleClass, key);
-            const exports = this.buildExportSet(allExports, allProviders, importedProviders);
-            this.cacheExports(moduleClass, key, exports);
-            if (isGlobal) {
-                for (const token of exports){
-                    this.globalExports.add(token);
-                }
-            }
-            // Call configure() if the module implements NestModule. The module is
-            // resolved through the container so it can have its own DI dependencies.
-            if (implementsNestModule(moduleClass)) {
-                if (!this.container.hasInScope(moduleClass, moduleId)) {
-                    this.container.register(moduleClass, moduleId);
-                }
-                const instance = this.container.resolve(moduleClass, moduleId);
-                const builder = new MiddlewareBuilder();
-                instance.configure(builder);
-                this.consumerMiddlewareDefinitions.push(...builder.getDefinitions());
-            }
-            return exports;
-        } finally{
-            this.processingStack.delete(stackKey);
-        }
-    }
-    warnOnMixedDefaultAndKeyed(parentName, keysByClass) {
-        const mode = this.container.getDiagnostics();
-        if (mode === "silent") return;
-        for (const [cls, keys] of keysByClass){
-            if (keys.size < 2) continue;
-            if (!keys.has(DEFAULT_KEY)) continue;
-            const message = `[vela] ${cls.name} imported in both bare and keyed form in '${parentName}'. ` + `These resolve to distinct module instances; consumers asking for an exported ` + `token will hit MultipleProvidersFoundError. Use one form consistently.`;
-            if (mode === "throw") throw new Error(message);
-            console.warn(message);
-        }
-    }
-    /** Registers the provider and returns the token it was registered under. */ registerProvider(provider, moduleId) {
-        if (typeof provider === "function") {
-            // Per-module bucket: the same class can be registered in multiple
-            // modules' buckets simultaneously without collision.
-            this.container.register(provider, moduleId);
-            this.registeredProviders.push(provider);
-            return provider;
-        }
-        const token = provider.provide;
-        if (!token) {
-            this.container.register(provider, moduleId);
-            return undefined;
-        }
-        if (this.isAppToken(token)) {
-            // Multiple APP_* providers within the same module bucket need
-            // distinct tokens so they don't overwrite each other in the bucket
-            // Map. Across buckets, `container.resolveAll(APP_GUARD)` walks
-            // every bucket — no need to mark synthetic tokens global.
-            const syntheticToken = new InjectionToken(`${token.toString()}:${this.appProviderCounter++}`);
-            this.container.register({
-                ...provider,
-                provide: syntheticToken
-            }, moduleId);
-            this.registeredProviders.push(syntheticToken);
-            getOrCreateArray(this.appProviderTokens, token).push(syntheticToken);
-            return syntheticToken;
-        }
-        this.container.register(provider, moduleId);
-        this.registeredProviders.push(token);
-        return token;
-    }
-    isAppToken(token) {
-        return APP_TOKENS.has(token);
-    }
-    buildExportSet(exports, providers, importedProviders) {
-        const exportSet = new Set();
-        const providerTokens = new Set();
-        for (const p of providers){
-            const token = tokenOfProvider(p);
-            if (token !== undefined) providerTokens.add(token);
-        }
-        for (const exported of exports){
-            const isLocalProvider = providerTokens.has(exported);
-            const isImportedProvider = importedProviders.has(exported);
-            if (!isLocalProvider && !isImportedProvider) {
-                const name = typeof exported === 'function' ? exported.name : String(exported);
-                console.warn(`Warning: Exporting '${name}' which is neither a local provider nor imported from another module.`);
-            }
-            exportSet.add(exported);
-        }
-        return exportSet;
-    }
-    getControllers() {
-        return [
-            ...this.collectedControllers
-        ];
-    }
-    getRegisteredProviders() {
-        return [
-            ...this.registeredProviders
-        ];
-    }
-    getAppProviderTokens(token) {
-        return [
-            ...this.appProviderTokens.get(token) ?? []
-        ];
-    }
-    getConsumerMiddlewareDefinitions() {
-        return [
-            ...this.consumerMiddlewareDefinitions
-        ];
-    }
-    /**
-   * Every lazy module instance recorded during load. Handed to the
-   * LazyModuleManager at bootstrap; empty when no module opted in.
-   */ getLazyGroups() {
-        return [
-            ...this.lazyGroups.values()
-        ];
-    }
-    /**
-   * A token is deferred iff EVERY module bucket holding it belongs to a lazy
-   * module instance — a token also registered by a non-lazy module stays on
-   * the eager pass (and resolving it there claims the lazy sibling, which is
-   * the "any use = init" semantic, not a bug).
-   */ isLazyOnlyToken(token) {
-        if (this.lazyModuleIds.size === 0) return false;
-        const owners = this.container.getOwnerModuleIds(token);
-        if (owners.length === 0) return false;
-        return owners.every((id)=>this.lazyModuleIds.has(id));
-    }
-    async resolveAllInstances() {
-        const instanceSet = new Set();
-        for (const token of this.registeredProviders){
-            try {
-                if (this.container.getProviderScope(token) === Scope.REQUEST) {
-                    continue;
-                }
-                if (this.isLazyOnlyToken(token)) {
-                    continue;
-                }
-                const instance = await this.container.resolveAsync(token);
-                instanceSet.add(instance);
-            } catch (err) {
-                if (err instanceof ModuleVisibilityError || err instanceof MultipleProvidersFoundError) {
-                    throw err;
-                }
-                this.routeError(err, `resolve provider`);
-            }
-        }
-        for (const controller of this.collectedControllers){
-            try {
-                if (this.container.getProviderScope(controller) === Scope.REQUEST) {
-                    continue;
-                }
-                if (this.isLazyOnlyToken(controller)) {
-                    continue;
-                }
-                const instance = await this.container.resolveAsync(controller);
-                instanceSet.add(instance);
-            } catch (err) {
-                if (err instanceof ModuleVisibilityError || err instanceof MultipleProvidersFoundError) {
-                    throw err;
-                }
-                this.routeError(err, `resolve controller ${controller.name}`);
-            }
-        }
-        return [
-            ...instanceSet
-        ];
-    }
-    routeError(err, context) {
-        const mode = this.container.getDiagnostics();
-        if (mode === "silent") return;
-        if (mode === "throw") {
-            throw err instanceof Error ? err : new Error(String(err));
-        }
-        console.warn(`[vela] ${context} failed:`, err);
-    }
-}

package/dist/module/stable-hash.d.ts

@@ -1,15 +0,0 @@
-/**
- * Deterministic, sync, edge-safe hash for module-instance discrimination.
- *
- * Walks values (objects/arrays/primitives/functions/class instances) into a
- * sorted, source-fingerprinting JSON string, then runs FNV-1a (32-bit) for a
- * compact 8-hex-char output.
- *
- * Functions and class instances are tolerated — they become `__fn:source` or
- * `__cls:ClassName` markers. Two distinct closures with the same source code
- * collide; module authors who care about that should pass an explicit `key`.
- *
- * Not cryptographic. Sufficient for discriminating module instances within
- * an app.
- */
-export declare function stableHash(value: unknown): string;

package/dist/module/stable-hash.js

@@ -1,52 +0,0 @@
-/**
- * Deterministic, sync, edge-safe hash for module-instance discrimination.
- *
- * Walks values (objects/arrays/primitives/functions/class instances) into a
- * sorted, source-fingerprinting JSON string, then runs FNV-1a (32-bit) for a
- * compact 8-hex-char output.
- *
- * Functions and class instances are tolerated — they become `__fn:source` or
- * `__cls:ClassName` markers. Two distinct closures with the same source code
- * collide; module authors who care about that should pass an explicit `key`.
- *
- * Not cryptographic. Sufficient for discriminating module instances within
- * an app.
- */ export function stableHash(value) {
-    return fnv1a(stableStringify(value));
-}
-function stableStringify(value) {
-    if (value === null || value === undefined) return JSON.stringify(value) ?? 'undefined';
-    if (typeof value === 'function') {
-        // Source-fingerprint via FNV-1a so we don't bloat the parent hash; this
-        // keeps two distinct factory functions distinguishable as long as their
-        // source differs (the common case). Names are intentionally excluded —
-        // two arrow functions with the same body should dedup.
-        return `__fn:${fnv1a(value.toString())}`;
-    }
-    if (typeof value === 'symbol') {
-        return `__sym:${value.description ?? ''}`;
-    }
-    if (typeof value !== 'object') return JSON.stringify(value);
-    if (Array.isArray(value)) {
-        return '[' + value.map(stableStringify).join(',') + ']';
-    }
-    const proto = Object.getPrototypeOf(value);
-    if (proto !== null && proto !== Object.prototype) {
-        const name = proto?.constructor?.name ?? 'AnonymousClass';
-        return `__cls:${name}` + stringifyOwnProps(value);
-    }
-    return stringifyOwnProps(value);
-}
-function stringifyOwnProps(obj) {
-    const keys = Object.keys(obj).sort();
-    const parts = keys.map((k)=>JSON.stringify(k) + ':' + stableStringify(obj[k]));
-    return '{' + parts.join(',') + '}';
-}
-function fnv1a(s) {
-    let h = 0x811c9dc5;
-    for(let i = 0; i < s.length; i++){
-        h ^= s.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return (h >>> 0).toString(16).padStart(8, '0');
-}

package/dist/module/types.d.ts

@@ -1 +0,0 @@
-export type { AsyncModuleOptions, DynamicModule, ModuleImport, ModuleMetadata, ModuleOptions, } from '../registry/types';

package/dist/module/types.js

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

package/dist/openapi/decorators.d.ts

@@ -1,34 +0,0 @@
-import type { ApiDocMetadata, ApiResponseEntry, ApiResponseOptions } from './types';
-export declare const API_DOC_METADATA = "vela:openapi:doc";
-export declare const API_TAGS_METADATA = "vela:openapi:tags";
-export declare const API_RESPONSES_METADATA = "vela:openapi:responses";
-/**
- * Attach OpenAPI documentation to a route handler (or controller).
- *
- * ```ts
- * @Get('/:id')
- * @ApiDoc({ summary: 'Get a user', description: '...', operationId: 'getUser' })
- * findOne(@Param('id') id: string) { ... }
- * ```
- */
-export declare function ApiDoc(metadata: ApiDocMetadata): MethodDecorator & ClassDecorator;
-/**
- * Attach OpenAPI tags to a controller or handler. Handler-level tags merge
- * with controller-level tags; duplicates are de-duplicated in the output.
- */
-export declare function ApiTags(...tags: string[]): MethodDecorator & ClassDecorator;
-export declare function getApiDoc(target: object, propertyKey?: string | symbol): ApiDocMetadata | undefined;
-export declare function getApiTags(target: object, propertyKey?: string | symbol): string[] | undefined;
-/**
- * Document a response for a given status code. Stackable: apply multiple
- * times on the same handler to declare different statuses.
- *
- * ```ts
- * @Get('/:id')
- * @ApiResponse(200, { description: 'Found', schema: UserDto })
- * @ApiResponse(404, { description: 'Not found', schema: ErrorDto })
- * findOne() { ... }
- * ```
- */
-export declare function ApiResponse(status: number | string, options: ApiResponseOptions): MethodDecorator;
-export declare function getApiResponses(target: object, propertyKey: string | symbol): ApiResponseEntry[] | undefined;

package/dist/openapi/decorators.js

@@ -1,66 +0,0 @@
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-export const API_DOC_METADATA = 'vela:openapi:doc';
-export const API_TAGS_METADATA = 'vela:openapi:tags';
-export const API_RESPONSES_METADATA = 'vela:openapi:responses';
-/**
- * Attach OpenAPI documentation to a route handler (or controller).
- *
- * ```ts
- * @Get('/:id')
- * @ApiDoc({ summary: 'Get a user', description: '...', operationId: 'getUser' })
- * findOne(@Param('id') id: string) { ... }
- * ```
- */ export function ApiDoc(metadata) {
-    return (target, propertyKey)=>{
-        if (propertyKey !== undefined) {
-            MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, API_DOC_METADATA, metadata);
-        } else {
-            MetadataRegistry.setCustomClassMeta(target, API_DOC_METADATA, metadata);
-        }
-    };
-}
-/**
- * Attach OpenAPI tags to a controller or handler. Handler-level tags merge
- * with controller-level tags; duplicates are de-duplicated in the output.
- */ export function ApiTags(...tags) {
-    return (target, propertyKey)=>{
-        if (propertyKey !== undefined) {
-            MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, API_TAGS_METADATA, tags);
-        } else {
-            MetadataRegistry.setCustomClassMeta(target, API_TAGS_METADATA, tags);
-        }
-    };
-}
-export function getApiDoc(target, propertyKey) {
-    if (propertyKey !== undefined) {
-        return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_DOC_METADATA);
-    }
-    return MetadataRegistry.getCustomClassMeta(target, API_DOC_METADATA);
-}
-export function getApiTags(target, propertyKey) {
-    if (propertyKey !== undefined) {
-        return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_TAGS_METADATA);
-    }
-    return MetadataRegistry.getCustomClassMeta(target, API_TAGS_METADATA);
-}
-/**
- * Document a response for a given status code. Stackable: apply multiple
- * times on the same handler to declare different statuses.
- *
- * ```ts
- * @Get('/:id')
- * @ApiResponse(200, { description: 'Found', schema: UserDto })
- * @ApiResponse(404, { description: 'Not found', schema: ErrorDto })
- * findOne() { ... }
- * ```
- */ export function ApiResponse(status, options) {
-    return (target, propertyKey)=>{
-        MetadataRegistry.appendCustomHandlerMeta(target.constructor, propertyKey, API_RESPONSES_METADATA, {
-            status,
-            ...options
-        });
-    };
-}
-export function getApiResponses(target, propertyKey) {
-    return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_RESPONSES_METADATA);
-}

package/dist/openapi/document.d.ts

@@ -1,3 +0,0 @@
-import type { Type } from '../container/types';
-import type { CreateOpenApiDocumentOptions, OpenApiDocument } from './types';
-export declare function createOpenApiDocument(rootModule: Type, options?: CreateOpenApiDocumentOptions): OpenApiDocument;