@zenofolio/hyper-decor 1.0.4 → 1.0.8

package/dist/common/helpers/scopes.d.ts

@@ -16,8 +16,8 @@ export declare const getScopes: (request: Request) => string[] | undefined;
 /**
  * Check if request has required scopes
  *
- * @param request
- * @param scopes
- * @returns
+ * @param request - The incoming request
+ * @param scopes - Required scopes to check
+ * @returns `true` if the request has all required scopes, otherwise `false`
  */
 export declare const hasScopes: (request: Request, scopes: HyperScopeOptions) => boolean;

package/dist/common/helpers/scopes.js

@@ -33,15 +33,14 @@ exports.getScopes = getScopes;
 /**
  * Check if request has required scopes
  *
- * @param request
- * @param scopes
- * @returns
+ * @param request - The incoming request
+ * @param scopes - Required scopes to check
+ * @returns `true` if the request has all required scopes, otherwise `false`
  */
 const hasScopes = (request, scopes) => {
-    const requestScopes = (0, exports.getScopes)(request);
-    if (!requestScopes) {
-        return false;
-    }
-    return (0, object_util_1.$array)(scopes).every((scope) => requestScopes.includes(scope));
+    const requestScopes = new Set((0, exports.getScopes)(request) || []);
+    if (requestScopes.has("*"))
+        return true;
+    return (0, object_util_1.$array)(scopes).every(scope => requestScopes.has(scope));
 };
 exports.hasScopes = hasScopes;

package/dist/common/helpers/state.d.ts

@@ -0,0 +1,17 @@
+import type { Request } from "hyper-express";
+/**
+ * Save a custom value against the request directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} value
+ */
+export declare const setValue: (request: Request, key: string, value: any) => void;
+/**
+ * Get a custom value from the request object directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} defaultValue
+ */
+export declare const getValue: <T>(request: Request, key: string, defaultValue?: T) => T | any;

package/dist/common/helpers/state.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValue = exports.setValue = void 0;
+const STATE_SYMBOL = Symbol("HYPER_DECOR_REQUEST_STATE");
+/**
+ * Get or create the internal state map for the request
+ * @param request
+ * @returns
+ */
+function getStore(request) {
+    if (!request[STATE_SYMBOL]) {
+        request[STATE_SYMBOL] = new Map();
+    }
+    return request[STATE_SYMBOL];
+}
+/**
+ * Save a custom value against the request directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} value
+ */
+const setValue = (request, key, value) => {
+    const store = getStore(request);
+    if (value === undefined) {
+        store.delete(key);
+        return;
+    }
+    store.set(key, value);
+};
+exports.setValue = setValue;
+/**
+ * Get a custom value from the request object directly via an internal Map
+ *
+ * @param {Request} request
+ * @param {string} key
+ * @param {any} defaultValue
+ */
+const getValue = (request, key, defaultValue) => {
+    const store = getStore(request);
+    const value = store.get(key);
+    return value !== undefined ? value : defaultValue;
+};
+exports.getValue = getValue;

package/dist/common/message-bus.d.ts

@@ -0,0 +1,11 @@
+import { IMessageTransport } from "./transport";
+export declare class MessageBus {
+    private transports;
+    registerTransport(transport: IMessageTransport): void;
+    emit(topic: string, data: any): Promise<void>;
+    listen(topic: string, handler: (data: any) => Promise<void> | void): Promise<void>;
+    /**
+     * Static helper to emit messages without resolving the bus manually.
+     */
+    static emit(topic: string, data: any): Promise<void>;
+}

package/dist/common/message-bus.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var MessageBus_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBus = void 0;
+const tsyringe_1 = require("tsyringe");
+let MessageBus = MessageBus_1 = class MessageBus {
+    constructor() {
+        this.transports = [];
+    }
+    registerTransport(transport) {
+        this.transports.push(transport);
+    }
+    emit(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.transports.map((t) => t.emit(topic, data)));
+        });
+    }
+    listen(topic, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(this.transports.map((t) => t.listen(topic, handler)));
+        });
+    }
+    /**
+     * Static helper to emit messages without resolving the bus manually.
+     */
+    static emit(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bus = tsyringe_1.container.resolve(MessageBus_1);
+            yield bus.emit(topic, data);
+        });
+    }
+};
+exports.MessageBus = MessageBus;
+exports.MessageBus = MessageBus = MessageBus_1 = __decorate([
+    (0, tsyringe_1.singleton)()
+], MessageBus);

package/dist/common/testing.d.ts

@@ -0,0 +1,56 @@
+import "reflect-metadata";
+import { InjectionToken } from "tsyringe";
+import { Constructor, HyperAppMetadata, ImportType } from "../lib/server/decorators/types";
+export type Token<T = any> = InjectionToken<T> | Constructor<T> | string | (abstract new (...args: any[]) => T);
+/**
+ * 🧪 TestingModule
+ * Holds the context of a compiled test environment.
+ */
+export declare class TestingModule {
+    private target?;
+    constructor(target?: Constructor | undefined);
+    /**
+     * Resolves a dependency from the container and ensures it's initialized.
+     */
+    resolve<T>(token: Token<T>): Promise<T>;
+    /**
+     * Shortcut for resolve (consistent with NestJS)
+     */
+    get<T>(token: Token<T>): Promise<T>;
+    /**
+     * Creates the full HyperExpress application proxy.
+     */
+    createHyperApplication(): Promise<any>;
+}
+/**
+ * 🛠️ TestingModuleBuilder
+ * Fluent API for configuring the testing module.
+ */
+export declare class TestingModuleBuilder {
+    private metadata;
+    constructor(metadata: Partial<HyperAppMetadata>);
+    overrideProvider(token: Token): any;
+    compile(): Promise<TestingModule>;
+}
+/**
+ * 🚀 HyperTest
+ * Entry point for creating testing environments.
+ */
+export declare class HyperTest {
+    /**
+     * Ultra-simple one-liner to boot a module or app.
+     * const module = await HyperTest.create(AppModule);
+     */
+    static create(Target: Constructor, options?: {
+        providers?: ImportType[];
+    }): Promise<TestingModule>;
+    /**
+     * Full builder API for complex configurations.
+     */
+    static createTestingModule(metadata: Partial<HyperAppMetadata>): TestingModuleBuilder;
+    /**
+     * Resets the global container instances (but keeps registrations).
+     * Useful between tests when isolation is not possible.
+     */
+    static reset(): void;
+}

package/dist/common/testing.js

@@ -0,0 +1,193 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperTest = exports.TestingModuleBuilder = exports.TestingModule = void 0;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+const stores_1 = require("../__internals/stores");
+const lifecycle_helper_1 = require("../__internals/helpers/lifecycle.helper");
+const bootstrap_1 = require("./bootstrap");
+const HyperApp_1 = require("../lib/server/decorators/HyperApp");
+/**
+ * 🧪 TestingModule
+ * Holds the context of a compiled test environment.
+ */
+class TestingModule {
+    constructor(target) {
+        this.target = target;
+    }
+    /**
+     * Resolves a dependency from the container and ensures it's initialized.
+     */
+    resolve(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield deepResolve(token);
+        });
+    }
+    /**
+     * Shortcut for resolve (consistent with NestJS)
+     */
+    get(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.resolve(token);
+        });
+    }
+    /**
+     * Creates the full HyperExpress application proxy.
+     */
+    createHyperApplication() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.target) {
+                throw new Error("Cannot create application without a target module/app.");
+            }
+            return yield (0, bootstrap_1.createApplication)(this.target);
+        });
+    }
+}
+exports.TestingModule = TestingModule;
+/**
+ * 🛠️ TestingModuleBuilder
+ * Fluent API for configuring the testing module.
+ */
+class TestingModuleBuilder {
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    overrideProvider(token) {
+        return {
+            useValue: (value) => {
+                tsyringe_1.container.register(token, { useValue: value });
+                return this;
+            },
+            useClass: (target) => {
+                tsyringe_1.container.register(token, { useClass: target });
+                return this;
+            },
+            useFactory: (factory) => {
+                tsyringe_1.container.register(token, { useFactory: factory });
+                return this;
+            }
+        };
+    }
+    compile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Create a synthetic app if needed
+            let SyntheticApp = class SyntheticApp {
+            };
+            SyntheticApp = __decorate([
+                (0, HyperApp_1.HyperApp)(this.metadata)
+            ], SyntheticApp);
+            // 2. Deep initialize all defined imports/providers
+            if (this.metadata.imports) {
+                for (const item of this.metadata.imports) {
+                    const token = typeof item === "object" && "token" in item ? item.token : item;
+                    yield deepResolve(token);
+                }
+            }
+            return new TestingModule(SyntheticApp);
+        });
+    }
+}
+exports.TestingModuleBuilder = TestingModuleBuilder;
+/**
+ * 🚀 HyperTest
+ * Entry point for creating testing environments.
+ */
+class HyperTest {
+    /**
+     * Ultra-simple one-liner to boot a module or app.
+     * const module = await HyperTest.create(AppModule);
+     */
+    static create(Target, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const builder = this.createTestingModule({
+                imports: [Target, ...((options === null || options === void 0 ? void 0 : options.providers) || [])]
+            });
+            const module = yield builder.compile();
+            // Ensure the target itself is deep-resolved
+            yield deepResolve(Target);
+            return module;
+        });
+    }
+    /**
+     * Full builder API for complex configurations.
+     */
+    static createTestingModule(metadata) {
+        return new TestingModuleBuilder(metadata);
+    }
+    /**
+     * Resets the global container instances (but keeps registrations).
+     * Useful between tests when isolation is not possible.
+     */
+    static reset() {
+        tsyringe_1.container.clearInstances();
+    }
+}
+exports.HyperTest = HyperTest;
+/**
+ * 🔄 deepResolve
+ * Recursively resolves a token and ensures its onInit chain is executed.
+ */
+function deepResolve(token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const instance = tsyringe_1.container.resolve(token);
+        // 1. Get the actual implementation constructor to inspect dependencies.
+        // We prefer instance.constructor because if token is an abstract class,
+        // dependencies are defined on the implementation.
+        const target = (instance === null || instance === void 0 ? void 0 : instance.constructor) || (typeof token === "function" ? token : null);
+        // 2. Recursive resolution of dependencies (Bottom-up initialization)
+        if (target && typeof target === "function") {
+            const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+            const injectionTokens = Reflect.getOwnMetadata("injectionTokens", target) || {};
+            for (let i = 0; i < paramTypes.length; i++) {
+                // Use @inject token if present, otherwise use design:paramtype
+                const dep = injectionTokens[i] || paramTypes[i];
+                // Avoid cycles or primitives
+                if (dep && typeof dep === "function" && dep !== Object && dep !== Array && dep !== String && dep !== Number && dep !== Boolean) {
+                    yield deepResolve(dep);
+                }
+            }
+        }
+        // 3. Metadata Discovery (traversing @HyperApp, @HyperModule, etc.)
+        const metadata = stores_1.HyperMeta.get(target);
+        if (metadata) {
+            // Resolve imports
+            if (metadata.imports && Array.isArray(metadata.imports)) {
+                for (const item of metadata.imports) {
+                    const depToken = typeof item === "object" && item !== null && "token" in item ? item.token : item;
+                    if (depToken)
+                        yield deepResolve(depToken);
+                }
+            }
+            // Resolve modules recursively
+            if (metadata.modules && Array.isArray(metadata.modules)) {
+                for (const m of metadata.modules) {
+                    yield deepResolve(m);
+                }
+            }
+            // Resolve controllers
+            if (metadata.controllers && Array.isArray(metadata.controllers)) {
+                for (const c of metadata.controllers) {
+                    yield deepResolve(c);
+                }
+            }
+        }
+        // 4. Initialize the instance itself
+        yield (0, lifecycle_helper_1.initializeInstance)(instance);
+        return instance;
+    });
+}

package/dist/common/transport.d.ts

@@ -0,0 +1,10 @@
+export interface IMessageTransport {
+    listen(topic: string, handler: (data: any) => Promise<void> | void): Promise<void>;
+    emit(topic: string, data: any): Promise<void>;
+}
+export declare class InternalTransport implements IMessageTransport {
+    private emitter;
+    private wildcardHandlers;
+    listen(topic: string, handler: (data: any) => Promise<void> | void): Promise<void>;
+    emit(topic: string, data: any): Promise<void>;
+}

package/dist/common/transport.js

@@ -0,0 +1,59 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalTransport = void 0;
+const tsyringe_1 = require("tsyringe");
+const eventemitter3_1 = require("eventemitter3");
+let InternalTransport = class InternalTransport {
+    constructor() {
+        this.emitter = new eventemitter3_1.EventEmitter();
+        this.wildcardHandlers = [];
+    }
+    listen(topic, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (topic.includes("*")) {
+                const patternString = topic
+                    .replace(/[+?^${}()|[\]\\]/g, "\\$&")
+                    .replace(/\./g, "\\.")
+                    .replace(/\*/g, ".*");
+                this.wildcardHandlers.push({
+                    pattern: new RegExp(`^${patternString}$`),
+                    handler,
+                });
+            }
+            else {
+                this.emitter.on(topic, handler);
+            }
+        });
+    }
+    emit(topic, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Regular emit
+            this.emitter.emit(topic, data);
+            // 2. Wildcard checks
+            for (const item of this.wildcardHandlers) {
+                if (item.pattern.test(topic)) {
+                    yield item.handler(data);
+                }
+            }
+        });
+    }
+};
+exports.InternalTransport = InternalTransport;
+exports.InternalTransport = InternalTransport = __decorate([
+    (0, tsyringe_1.singleton)()
+], InternalTransport);

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const HYPER_SCOPES_KEY = "__HYPER_SCOPES_KEY";
 export declare const HYPER_ROLE_KEY = "__HYPER_ROLE_KEY";
 export declare const HYPER_PASS_KEY = "__HYPER_PASS_KEY";
+export declare const FULL_ACCESS = "*";

package/dist/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HYPER_PASS_KEY = exports.HYPER_ROLE_KEY = exports.HYPER_SCOPES_KEY = void 0;
+exports.FULL_ACCESS = exports.HYPER_PASS_KEY = exports.HYPER_ROLE_KEY = exports.HYPER_SCOPES_KEY = void 0;
 exports.HYPER_SCOPES_KEY = "__HYPER_SCOPES_KEY";
 exports.HYPER_ROLE_KEY = "__HYPER_ROLE_KEY";
 exports.HYPER_PASS_KEY = "__HYPER_PASS_KEY";
+exports.FULL_ACCESS = "*";

package/dist/decorators.d.ts

@@ -0,0 +1 @@
+export * from "./lib/server/decorators";

package/dist/{common/openapi/index.js → decorators.js}

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./collect-class-data"), exports);
-__exportStar(require("./collect-function-data"), exports);
+__exportStar(require("./lib/server/decorators"), exports);

package/dist/extension.js

@@ -18,6 +18,9 @@ const requestMethods = {
     setScopes(scopes) {
         (0, helpers_1.setScopes)(this, scopes);
     },
+    setFullScopes() {
+        (0, helpers_1.setScopes)(this, ["*"]);
+    },
     hasScopes(scopes) {
         return (0, helpers_1.hasScopes)(this, scopes);
     },
@@ -25,8 +28,14 @@ const requestMethods = {
         return (0, helpers_1.getScopes)(this);
     },
     setRoleScopes(role, scopes) {
-        this.setRole(role);
-        this.setScopes(scopes);
+        (0, helpers_1.setRole)(this, role);
+        (0, helpers_1.setScopes)(this, scopes);
+    },
+    setValue(key, value) {
+        (0, helpers_1.setValue)(this, key, value);
+    },
+    getValue(key, defaultValue) {
+        return (0, helpers_1.getValue)(this, key, defaultValue);
     },
 };
 /////////////////////////////

package/dist/index.d.ts

@@ -1,9 +1,17 @@
-export * from "./exeptions";
+import "./extension";
+export * from "./lib/server/exeptions";
 export * from "./constants";
 export * from "./extension";
-export * from "./decorators";
+export * from "./lib/server/decorators";
 export * from "./common/helpers";
+export * from "./lib/tree/tree";
 export * from "./common/bootstrap";
 export * from "hyper-express";
 export * from "tsyringe";
-export * from "./type";
+export * from "./__internals/stores";
+export * from "./__internals/types";
+export * from "./common/transport";
+export * from "./common/message-bus";
+export * from "./__internals/transform/transform.registry";
+export * from "./lib/openapi";
+export * from "./common/testing";

package/dist/index.js

@@ -14,12 +14,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./exeptions"), exports);
+require("./extension");
+__exportStar(require("./lib/server/exeptions"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./extension"), exports);
-__exportStar(require("./decorators"), exports);
+__exportStar(require("./lib/server/decorators"), exports);
 __exportStar(require("./common/helpers"), exports);
+__exportStar(require("./lib/tree/tree"), exports);
 __exportStar(require("./common/bootstrap"), exports);
 __exportStar(require("hyper-express"), exports);
 __exportStar(require("tsyringe"), exports);
-__exportStar(require("./type"), exports);
+__exportStar(require("./__internals/stores"), exports);
+__exportStar(require("./__internals/types"), exports);
+__exportStar(require("./common/transport"), exports);
+__exportStar(require("./common/message-bus"), exports);
+__exportStar(require("./__internals/transform/transform.registry"), exports);
+__exportStar(require("./lib/openapi"), exports);
+__exportStar(require("./common/testing"), exports);

package/dist/lib/event/meta.store.d.ts

@@ -0,0 +1,4 @@
+export declare const EventMeta: {
+    set: (target: object, propertyKey: any, data: object) => void;
+    get: (target: object, propertyKey?: any) => object;
+};

package/dist/lib/event/meta.store.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventMeta = void 0;
+const stores_1 = require("../../__internals/stores");
+exports.EventMeta = stores_1.Metadata.prefix("event");

package/dist/lib/openapi/collectors/class.collector.d.ts

@@ -0,0 +1,5 @@
+import { Constructor } from '../../server/decorators/types';
+/**
+ * 🏢 Extracts class-level OpenAPI metadata (Tags, Security, etc.)
+ */
+export declare function collectClassMetadata(Target: Constructor): object;

package/dist/lib/openapi/collectors/class.collector.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectClassMetadata = collectClassMetadata;
+const metadata_1 = require("../metadata");
+/**
+ * 🏢 Extracts class-level OpenAPI metadata (Tags, Security, etc.)
+ */
+function collectClassMetadata(Target) {
+    return metadata_1.SwaggerMeta.get(Target);
+}

package/dist/lib/openapi/collectors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './class.collector';
+export * from './method.collector';
+export * from './schema.collector';

package/dist/lib/openapi/collectors/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./class.collector"), exports);
+__exportStar(require("./method.collector"), exports);
+__exportStar(require("./schema.collector"), exports);

package/dist/lib/openapi/collectors/method.collector.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { Operation } from '../types';
+import { Constructor } from '../../server/decorators/types';
+/**
+ * 🛠️ Consolidates framework metadata and OpenAPI decorators into a single Operation object.
+ */
+export declare function collectMethodMetadata(target: Constructor, propertyKey?: string): Operation | undefined;