@zenofolio/hyper-decor 1.0.72 → 1.0.74

package/dist/lib/server/decorators/Scope.d.ts

@@ -0,0 +1,7 @@
+import "reflect-metadata";
+import { ScopeType } from "./types";
+/**
+ * 🚀 Scope Decorator
+ * Purely injects scope metadata into the target class or method.
+ */
+export declare const Scope: <T extends string = string>(scopes: ScopeType<T>) => (target: any, propertyKey?: any) => void;

package/dist/lib/server/decorators/Scope.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 Scope Decorator
+ * Purely injects scope metadata into the target class or method.
+ */
+const Scope = (scopes) => (target, propertyKey) => {
+    const _scopes = Array.isArray(scopes) ? scopes : [scopes];
+    metadata_1.HyperMeta.set(target, propertyKey, { scopes: _scopes });
+};
+exports.Scope = Scope;

package/dist/lib/server/decorators/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./metadata";
+export * from "./types";
+export * from "./HyperApp";
+export * from "./HyperModule";
+export * from "./HyperController";
+export * from "./HyperService";
+export * from "./Routes";
+export * from "./Http";
+export * from "./Role";
+export * from "./Scope";
+export * from "./Output";
+export * from "./Middleware";
+export * from "./Pass";
+export * from "./File";
+export * from "./Messaging";
+export * from "./Output";

package/dist/lib/server/decorators/index.js

@@ -0,0 +1,32 @@
+"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("./metadata"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./HyperApp"), exports);
+__exportStar(require("./HyperModule"), exports);
+__exportStar(require("./HyperController"), exports);
+__exportStar(require("./HyperService"), exports);
+__exportStar(require("./Routes"), exports);
+__exportStar(require("./Http"), exports);
+__exportStar(require("./Role"), exports);
+__exportStar(require("./Scope"), exports);
+__exportStar(require("./Output"), exports);
+__exportStar(require("./Middleware"), exports);
+__exportStar(require("./Pass"), exports);
+__exportStar(require("./File"), exports);
+__exportStar(require("./Messaging"), exports);
+__exportStar(require("./Output"), exports);

package/dist/lib/server/decorators/metadata.d.ts

@@ -0,0 +1 @@
+export { HyperMeta } from "../../../__internals/stores/hyper.store";

package/dist/lib/server/decorators/metadata.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperMeta = void 0;
+var hyper_store_1 = require("../../../__internals/stores/hyper.store");
+Object.defineProperty(exports, "HyperMeta", { enumerable: true, get: function () { return hyper_store_1.HyperMeta; } });

package/dist/lib/server/decorators/types.d.ts

@@ -0,0 +1,125 @@
+import type { MiddlewareHandler, MiddlewareNext, Request, Response, ServerConstructorOptions } from "hyper-express";
+import { InjectionToken, RegistrationOptions } from "tsyringe";
+import { IMessageTransport } from "../../../common/transport";
+export interface OnInit {
+    onInit(): Promise<any>;
+}
+export interface IsSingleton {
+    isSingleton(): boolean;
+}
+export type Constructor<R = object> = new (...args: any[]) => R;
+export type ImportObject = {
+    token: InjectionToken;
+    useClass?: Constructor;
+    useValue?: any;
+    useFactory?: (...args: any[]) => any;
+    useToken?: InjectionToken;
+    options?: RegistrationOptions;
+};
+export type ImportType = Constructor<Partial<OnInit> & Partial<IsSingleton>> | InjectionToken | ImportObject;
+export type ConstructorDecorator = (target: Constructor, kay?: any, descriptor?: PropertyDescriptor) => Constructor;
+export type HyperClassDecorator<T> = (options?: T) => ConstructorDecorator;
+export type HyperMethodDecorator<T> = (options?: T) => (target: any, key?: any, descriptor?: PropertyDescriptor) => void;
+export interface LogSpaces {
+    modules: boolean;
+    controllers: boolean;
+    middleware: boolean;
+    routes: boolean;
+    messaging: boolean;
+}
+export interface IHyperHooks {
+    onBeforeInit?(instance: any, token: any, context: any): void | Promise<void>;
+    onAfterInit?(instance: any, token: any, context: any): void | Promise<void>;
+}
+export interface HyperAppMetadata {
+    name?: string;
+    version?: string;
+    description?: string;
+    author?: string;
+    license?: string;
+    prefix?: string;
+    logger?: (...args: any[]) => void;
+    logs?: Partial<LogSpaces>;
+    modules: Constructor[];
+    imports?: ImportType[];
+    options?: ServerConstructorOptions;
+    uwsOptions?: any;
+    transports?: IMessageTransport[];
+    hooks?: IHyperHooks | Constructor<IHyperHooks>;
+}
+export interface HyperAppDecorator {
+    (options?: HyperAppMetadata): (target: Constructor) => Constructor;
+}
+export type HyperModuleMetadata = {
+    path?: string;
+    name?: string;
+    roles?: string[];
+    scopes?: string[];
+    modules?: Constructor[];
+    controllers?: Constructor[];
+    imports?: ImportType[];
+};
+export type HyperModuleDecorator = HyperClassDecorator<HyperModuleMetadata>;
+export type HyperControllerMetadata = {
+    path?: string;
+    roles?: string[];
+    scopes?: string[];
+    imports?: ImportType[];
+};
+export type HyperControllerDecorator = HyperClassDecorator<HyperControllerMetadata | string>;
+export type ParameterResolver = (req: Request, res: Response) => any | Promise<any>;
+export type HyperParameterMetadata = {
+    params: {
+        index: number;
+        type: Constructor | Function;
+        source?: "body" | "query" | "params" | "headers" | "req" | "res";
+        picker?: string;
+        schema?: object | Function;
+        isWholeSource?: boolean;
+        name?: string;
+        decorator: string;
+        resolver?: ParameterResolver;
+    }[];
+};
+export type HyperParamDecorator = (key: string) => (target: any, key: string, index: number) => void;
+export type RoleMap<T> = {
+    role: T;
+    description: string;
+    message?: string;
+};
+/**
+ * Type definition for Role decorator.
+ * It can accept a single role, an array of roles, or a function that evaluates roles dynamically.
+ */
+export type RoleType<T extends string = string> = T | T[] | RoleMap<T> | RoleMap<T>[];
+export type ScopeMap<T extends string = string> = {
+    scope: T;
+    description: string;
+    message?: string;
+};
+/**
+ * Type definition for Scope decorator.
+ * It can accept a single scope or multiple scopes as an array of strings.
+ */
+export type ScopeType<T extends string = string> = T | T[] | ScopeMap<T> | ScopeMap<T>[];
+/**
+ * Type definition for Route metadata.
+ * Contains method, path, and other configuration for a specific method.
+ */
+export interface RouteMetadata {
+    method: string;
+    path: string;
+    propertyKey: string;
+    options?: Record<string, unknown>;
+}
+export declare abstract class MiddlewareClass {
+    abstract handle(req: Request, res: Response, next: MiddlewareNext): void;
+}
+export interface MiddlewareClassConstructor {
+    new (...args: any[]): MiddlewareClass;
+}
+/**
+ * Type definition for Middleware.
+ * Middleware can be a single handler or an array of handlers.
+ */
+export type MiddlewareType = MiddlewareHandler | MiddlewareClassConstructor;

package/dist/lib/server/decorators/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareClass = void 0;
+class MiddlewareClass {
+}
+exports.MiddlewareClass = MiddlewareClass;

package/dist/lib/server/exeptions/DuplicateControllerPathException.d.ts

@@ -0,0 +1,14 @@
+import HyperException from "./HyperException";
+export default class DuplicateControllerPathException extends HyperException {
+    constructor(data: {
+        path: string;
+        current: {
+            module: string;
+            controller: string;
+        };
+        duplicate: {
+            module: string;
+            controller: string;
+        };
+    });
+}

package/dist/lib/server/exeptions/DuplicateControllerPathException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class DuplicateControllerPathException extends HyperException_1.default {
+    constructor(data) {
+        super(`Duplicate controller path: '${data.path}' in ${data.current.module}/${data.current.controller} and ${data.duplicate.module} controller: ${data.duplicate.controller}`, "DuplicateControllerPathException", data);
+    }
+}
+exports.default = DuplicateControllerPathException;

package/dist/lib/server/exeptions/DuplicatedException.d.ts

@@ -0,0 +1,8 @@
+import HyperException from "./HyperException";
+export default class DuplicatedException extends HyperException {
+    constructor(data: {
+        path: string;
+        currentNameSpace: string;
+        duplicateNameSpace: string;
+    });
+}

package/dist/lib/server/exeptions/DuplicatedException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class DuplicatedException extends HyperException_1.default {
+    constructor(data) {
+        super(`Duplicate at path: '${data.path}' in ${data.currentNameSpace} and ${data.duplicateNameSpace}`, "DuplicatedException", data);
+    }
+}
+exports.default = DuplicatedException;

package/dist/lib/server/exeptions/DuplicatedHandlerException.d.ts

@@ -0,0 +1,4 @@
+import HyperException from "./HyperException";
+export default class DuplicatedHandlerException extends HyperException {
+    constructor(message: string);
+}

package/dist/lib/server/exeptions/DuplicatedHandlerException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class DuplicatedHandlerException extends HyperException_1.default {
+    constructor(message) {
+        super(message, "DuplicateHandlerException");
+    }
+}
+exports.default = DuplicatedHandlerException;

package/dist/lib/server/exeptions/HyperException.d.ts

@@ -0,0 +1,8 @@
+import { ExceptionType } from "./types";
+export default class HyperException extends Error {
+    code: ExceptionType;
+    additionalInfo: any;
+    status: number;
+    constructor(message: string, code?: ExceptionType, additionalInfo?: any, status?: number);
+    static throw(message: string, code?: ExceptionType, additionalInfo?: {}): void;
+}

package/dist/lib/server/exeptions/HyperException.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HyperException extends Error {
+    constructor(message, code = "HyperException", additionalInfo = {}, status = 500) {
+        super(message);
+        this.code = code;
+        this.additionalInfo = additionalInfo;
+        this.status = status;
+    }
+    static throw(message, code, additionalInfo = {}) {
+        throw new this(message, code, additionalInfo);
+    }
+}
+exports.default = HyperException;

package/dist/lib/server/exeptions/HyperFileException.d.ts

@@ -0,0 +1,4 @@
+import HyperException from "./HyperException";
+export default class HyperFileException extends HyperException {
+    constructor(message: string, additional?: any);
+}

package/dist/lib/server/exeptions/HyperFileException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class HyperFileException extends HyperException_1.default {
+    constructor(message, additional) {
+        super(message, "HyperFileException", additional, 400);
+    }
+}
+exports.default = HyperFileException;

package/dist/lib/server/exeptions/MethodNotFountException.d.ts

@@ -0,0 +1,4 @@
+import HyperException from "./HyperException";
+export default class MethodNotFountException extends HyperException {
+    constructor(className: string, method: string, path: string);
+}

package/dist/lib/server/exeptions/MethodNotFountException.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class MethodNotFountException extends HyperException_1.default {
+    constructor(className, method, path) {
+        super(`Method ${method} not exists in ${className} for path ${path}`, "MethodNotFountException");
+    }
+}
+exports.default = MethodNotFountException;

package/dist/lib/server/exeptions/NotPropertyException.d.ts

@@ -0,0 +1,6 @@
+import HyperException from "./HyperException";
+export default class NotPropertyException extends HyperException {
+    namespace: string;
+    target: any;
+    constructor(namespace: string, target: any);
+}

package/dist/lib/server/exeptions/NotPropertyException.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class NotPropertyException extends HyperException_1.default {
+    constructor(namespace, target) {
+        super(`This decorator cannot be used as a property decorator in ${namespace}`, "NotPropertyException", {
+            target,
+        });
+        this.namespace = namespace;
+        this.target = target;
+    }
+}
+exports.default = NotPropertyException;

package/dist/lib/server/exeptions/NotRoleException.d.ts

@@ -0,0 +1,6 @@
+import HyperException from "./HyperException";
+export default class NotRoleException extends HyperException {
+    roles: string[];
+    requiredRoles: string[];
+    constructor(message?: string, roles?: string[], requiredRoles?: string[]);
+}

package/dist/lib/server/exeptions/NotRoleException.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class NotRoleException extends HyperException_1.default {
+    constructor(message = `Has not Permission to access this resource`, roles = [], requiredRoles = []) {
+        super(message, "NotRoleException", {
+            roles,
+            requiredRoles,
+        }, 403);
+        this.roles = roles;
+        this.requiredRoles = requiredRoles;
+    }
+}
+exports.default = NotRoleException;

package/dist/lib/server/exeptions/NotScopeException.d.ts

@@ -0,0 +1,7 @@
+import HyperException from "./HyperException";
+export default class NotScopeException extends HyperException {
+    message: string;
+    requestScopes: string[];
+    requiredScopes: string[];
+    constructor(message: string, requestScopes?: string[], requiredScopes?: string[]);
+}

package/dist/lib/server/exeptions/NotScopeException.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class NotScopeException extends HyperException_1.default {
+    constructor(message, requestScopes = [], requiredScopes = []) {
+        super(message || `You don't have the required scopes to access this resource`, "NotScopeException", {
+            requestScopes,
+            requiredScopes,
+        }, 403);
+        this.message = message;
+        this.requestScopes = requestScopes;
+        this.requiredScopes = requiredScopes;
+    }
+}
+exports.default = NotScopeException;

package/dist/lib/server/exeptions/WrongPlaceException.d.ts

@@ -0,0 +1,8 @@
+import HyperException from "./HyperException";
+export default class WrongPlaceException extends HyperException {
+    decorator: string;
+    as: string;
+    namespace: string;
+    target: any;
+    constructor(decorator: string, as: string, namespace: string, target: any);
+}

package/dist/lib/server/exeptions/WrongPlaceException.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HyperException_1 = __importDefault(require("./HyperException"));
+class WrongPlaceException extends HyperException_1.default {
+    constructor(decorator, as, namespace, target) {
+        super(`The decorator @${decorator} only can be used as a ${as} decorator. Error => ${namespace}`, "WrongPlaceException", {
+            decorator,
+            target,
+            namespace,
+            as,
+        });
+        this.decorator = decorator;
+        this.as = as;
+        this.namespace = namespace;
+        this.target = target;
+    }
+}
+exports.default = WrongPlaceException;

package/dist/lib/server/exeptions/index.d.ts

@@ -0,0 +1,8 @@
+import DuplicatedHandlerException from "./DuplicatedHandlerException";
+import DuplicateControllerPathException from "./DuplicateControllerPathException";
+import HyperException from "./HyperException";
+import MethodNotFountException from "./MethodNotFountException";
+import NotRoleException from "./NotRoleException";
+import NotScopeException from "./NotScopeException";
+export type * from "./types";
+export { DuplicatedHandlerException, DuplicateControllerPathException as DuplicatedRouterException, HyperException, NotRoleException, NotScopeException, MethodNotFountException as MethodNotExists, };

package/dist/lib/server/exeptions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodNotExists = exports.NotScopeException = exports.NotRoleException = exports.HyperException = exports.DuplicatedRouterException = exports.DuplicatedHandlerException = void 0;
+const DuplicatedHandlerException_1 = __importDefault(require("./DuplicatedHandlerException"));
+exports.DuplicatedHandlerException = DuplicatedHandlerException_1.default;
+const DuplicateControllerPathException_1 = __importDefault(require("./DuplicateControllerPathException"));
+exports.DuplicatedRouterException = DuplicateControllerPathException_1.default;
+const HyperException_1 = __importDefault(require("./HyperException"));
+exports.HyperException = HyperException_1.default;
+const MethodNotFountException_1 = __importDefault(require("./MethodNotFountException"));
+exports.MethodNotExists = MethodNotFountException_1.default;
+const NotRoleException_1 = __importDefault(require("./NotRoleException"));
+exports.NotRoleException = NotRoleException_1.default;
+const NotScopeException_1 = __importDefault(require("./NotScopeException"));
+exports.NotScopeException = NotScopeException_1.default;

package/dist/lib/server/exeptions/types.d.ts

@@ -0,0 +1 @@
+export type ExceptionType = "DuplicateControllerException" | "DuplicateHandlerException" | "DuplicateRouterException" | "HyperException" | "NotRoleException" | "NotScopeException" | "MethodNotFountException" | "DuplicateControllerPathException" | "DuplicateHandlerException" | "DuplicatedException" | "NotPropertyException" | "WrongPlaceException" | "HyperFileException" | "DpublicateModuleException";

package/dist/lib/server/exeptions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/tree/tree.d.ts

@@ -0,0 +1,36 @@
+import { HyperAppMetadata, HyperModuleMetadata, HyperControllerMetadata, HyperParameterMetadata, RouteMetadata, ImportType, Constructor } from "../server/decorators/types";
+export interface AppTree {
+    app: HyperAppMetadata & {
+        target: object;
+        fullPath: string;
+    };
+    modules: Record<string, ModuleNode>;
+    paths: Record<string, RouteNode[]>;
+    openapi?: Record<string, unknown>;
+}
+export interface ModuleNode {
+    metadata: HyperModuleMetadata;
+    target: object;
+    fullPath: string;
+    modules: Record<string, ModuleNode>;
+    controllers: Record<string, ControllerNode>;
+    services: ImportType[];
+    openapi?: Record<string, unknown>;
+}
+export interface ControllerNode {
+    metadata: HyperControllerMetadata;
+    target: object;
+    fullPath: string;
+    routes: RouteNode[];
+    services: ImportType[];
+    openapi?: Record<string, unknown>;
+}
+export interface RouteNode extends RouteMetadata {
+    fullPath: string;
+    params: HyperParameterMetadata['params'];
+    openapi?: Record<string, unknown>;
+}
+/**
+ * Extracts the complete application metadata tree.
+ */
+export declare function getAppTree(Target: Constructor): AppTree;

package/dist/lib/tree/tree.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppTree = getAppTree;
+const meta_store_1 = require("../../__internals/stores/meta.store");
+const metadata_1 = require("../openapi/metadata");
+const path_util_1 = require("../../__internals/utils/path.util");
+const metadata_registry_1 = require("../openapi/metadata.registry");
+/**
+ * Extracts the complete application metadata tree.
+ */
+function getAppTree(Target) {
+    var _a;
+    const root = meta_store_1.Metadata.get(Target);
+    const common = (_a = root.server) === null || _a === void 0 ? void 0 : _a.common;
+    const prefix = (common === null || common === void 0 ? void 0 : common.prefix) || "/";
+    const tree = {
+        app: Object.assign(Object.assign({}, (common || {})), { target: Target, fullPath: prefix }),
+        modules: {},
+        paths: {}
+    };
+    const modules = (common === null || common === void 0 ? void 0 : common.modules) || [];
+    modules.forEach(m => {
+        const node = getModuleNode(m, prefix, tree.paths);
+        tree.modules[m.name] = node;
+    });
+    // Apply tree processors
+    metadata_registry_1.openApiRegistry.getProcessors().forEach(processor => processor(tree));
+    return tree;
+}
+function getModuleNode(Target, parentPath = "", globalPaths = {}) {
+    var _a;
+    const root = meta_store_1.Metadata.get(Target);
+    const common = (_a = root.server) === null || _a === void 0 ? void 0 : _a.common;
+    const currentPath = (0, path_util_1.join)(parentPath, (common === null || common === void 0 ? void 0 : common.path) || "");
+    const openapi = metadata_1.SwaggerMeta.get(Target); // Fixed: Metadata utility now returns root.common
+    // Execute custom collectors
+    metadata_registry_1.openApiRegistry.getCollectors("class").forEach(collector => {
+        const extra = collector(Target);
+        if (extra)
+            Object.assign(openapi, extra);
+    });
+    const node = {
+        metadata: common,
+        target: Target,
+        fullPath: currentPath,
+        modules: {},
+        controllers: {},
+        services: ((common === null || common === void 0 ? void 0 : common.imports) || []),
+        openapi: openapi
+    };
+    ((common === null || common === void 0 ? void 0 : common.modules) || []).forEach(m => {
+        node.modules[m.name] = getModuleNode(m, currentPath, globalPaths);
+    });
+    ((common === null || common === void 0 ? void 0 : common.controllers) || []).forEach(c => {
+        node.controllers[c.name] = getControllerNode(c, currentPath, globalPaths);
+    });
+    return node;
+}
+function getControllerNode(Target, parentPath = "", globalPaths = {}) {
+    var _a;
+    const root = meta_store_1.Metadata.get(Target);
+    const common = (_a = root.server) === null || _a === void 0 ? void 0 : _a.common;
+    const currentPath = (0, path_util_1.join)(parentPath, (common === null || common === void 0 ? void 0 : common.path) || "");
+    const openapi = metadata_1.SwaggerMeta.get(Target);
+    const server = root.server || { common: {}, methods: {} };
+    const methods = server.methods;
+    const routes = Object.keys(methods).map((propertyKey) => {
+        var _a;
+        const methodMeta = methods[propertyKey];
+        const route = methodMeta.route;
+        if (!route)
+            return null;
+        const params = ((_a = methodMeta.params) === null || _a === void 0 ? void 0 : _a.params) || [];
+        const fullPath = (0, path_util_1.join)(currentPath, route.path);
+        // Get OpenAPI metadata for the method
+        const methodOpenApi = (metadata_1.SwaggerMeta.get(Target, propertyKey) || {});
+        // Execute custom collectors
+        metadata_registry_1.openApiRegistry.getCollectors("method").forEach((collector) => {
+            const extra = collector(Target.prototype, propertyKey);
+            if (extra)
+                Object.assign(methodOpenApi, extra);
+        });
+        const routeNode = Object.assign(Object.assign({}, route), { fullPath,
+            params, openapi: methodOpenApi });
+        // Add to global paths map
+        if (!globalPaths[fullPath]) {
+            globalPaths[fullPath] = [];
+        }
+        globalPaths[fullPath].push(routeNode);
+        return routeNode;
+    }).filter(Boolean);
+    // Execute custom collectors
+    metadata_registry_1.openApiRegistry.getCollectors("class").forEach(collector => {
+        const extra = collector(Target);
+        if (extra)
+            Object.assign(openapi, extra);
+    });
+    return {
+        metadata: common,
+        target: Target,
+        fullPath: currentPath,
+        routes,
+        services: (common === null || common === void 0 ? void 0 : common.imports) || [],
+        openapi: openapi
+    };
+}