@zenofolio/hyper-decor 1.0.4 → 1.0.8

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = void 0;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 Middleware Decorator
+ * Purely injects middleware metadata into the target class or method.
+ */
+const Middleware = (...middleware) => (target, propertyKey) => {
+    const current = metadata_1.HyperMeta.get(target, propertyKey);
+    const existing = current.middlewares || [];
+    metadata_1.HyperMeta.set(target, propertyKey, {
+        middlewares: [...existing, ...middleware]
+    });
+};
+exports.Middleware = Middleware;
+/**
+ * Exclude middleware from matching paths.
+ */
+exports.Middleware.exclude = (expressions, middleware) => (target, propertyKey) => {
+    const handler = buildHandler("exclude", expressions, middleware);
+    const current = metadata_1.HyperMeta.get(target, propertyKey);
+    const existing = current.middlewares || [];
+    metadata_1.HyperMeta.set(target, propertyKey, {
+        middlewares: [...existing, handler]
+    });
+};
+/**
+ * Only run middleware on matching paths.
+ */
+exports.Middleware.only = (expressions, middleware) => (target, propertyKey) => {
+    const handler = buildHandler("only", expressions, middleware);
+    const current = metadata_1.HyperMeta.get(target, propertyKey);
+    const existing = current.middlewares || [];
+    metadata_1.HyperMeta.set(target, propertyKey, {
+        middlewares: [...existing, handler]
+    });
+};
+/**
+ * Helper function to build middleware handlers for "only" and "exclude" modes.
+ */
+const buildHandler = (mode, expressions, middleware) => {
+    const matchers = Array.isArray(expressions) ? expressions : [expressions];
+    return (req, res, next) => {
+        const matches = matchers.some((rx) => rx.test(req.path));
+        if ((mode === "only" && !matches) || (mode === "exclude" && matches)) {
+            return next();
+        }
+        return middleware(req, res, next);
+    };
+};

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

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+/**
+ * 🚀 Output Decorator
+ * Purely injects output schema metadata into the method.
+ */
+export declare function Output(schema?: any): (target: any, propertyKey?: any) => void;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Output = Output;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 Output Decorator
+ * Purely injects output schema metadata into the method.
+ */
+function Output(schema) {
+    return (target, propertyKey) => {
+        metadata_1.HyperMeta.set(target, propertyKey, { output: schema });
+    };
+}

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

@@ -0,0 +1,10 @@
+import "reflect-metadata";
+import { Request, Response } from "hyper-express";
+export interface PassOptions {
+    (req: Request, res: Response): boolean | Promise<boolean>;
+}
+/**
+ * 🚀 Pass Decorator
+ * Purely injects pass metadata into the target class or method.
+ */
+export declare const Pass: (options?: PassOptions | boolean) => any;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pass = void 0;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 Pass Decorator
+ * Purely injects pass metadata into the target class or method.
+ */
+const Pass = (options = true) => (target, propertyKey) => {
+    metadata_1.HyperMeta.set(target, propertyKey, { pass: options });
+};
+exports.Pass = Pass;

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

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

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

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

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

@@ -0,0 +1,14 @@
+import "reflect-metadata";
+export declare const Get: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Post: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Put: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Delete: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Patch: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Options: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Head: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Trace: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Any: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const All: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Connect: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const WS: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;
+export declare const Upgrade: (path?: string, options?: Record<string, unknown> | undefined) => (target: object, propertyKey?: any) => void;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Upgrade = exports.WS = exports.Connect = exports.All = exports.Any = exports.Trace = exports.Head = exports.Options = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = void 0;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+/**
+ * 🛠️ Helper to create route decorators
+ */
+function createRouteDecorator(method) {
+    return (path = "/", options) => {
+        return (target, propertyKey) => {
+            const returnType = Reflect.getMetadata("design:returntype", target, propertyKey);
+            metadata_1.HyperMeta.set(target, propertyKey, {
+                route: {
+                    method,
+                    path,
+                    propertyKey: propertyKey,
+                    options: options,
+                },
+                reflection: {
+                    output: returnType
+                }
+            });
+        };
+    };
+}
+exports.Get = createRouteDecorator("get");
+exports.Post = createRouteDecorator("post");
+exports.Put = createRouteDecorator("put");
+exports.Delete = createRouteDecorator("delete");
+exports.Patch = createRouteDecorator("patch");
+exports.Options = createRouteDecorator("options");
+exports.Head = createRouteDecorator("head");
+exports.Trace = createRouteDecorator("trace");
+exports.Any = createRouteDecorator("any");
+exports.All = createRouteDecorator("all");
+exports.Connect = createRouteDecorator("connect");
+exports.WS = createRouteDecorator("ws");
+exports.Upgrade = createRouteDecorator("upgrade");

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/{decorators → lib/server/decorators}/index.d.ts

@@ -1,11 +1,16 @@
+export * from "./metadata";
+export * from "./types";
 export * from "./HyperApp";
 export * from "./HyperModule";
 export * from "./HyperController";
-export * from "./Middleware";
-export * from "./Scope";
-export * from "./Role";
+export * from "./HyperService";
 export * from "./Routes";
-export * from "./types";
 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/{decorators → lib/server/decorators}/index.js

@@ -14,14 +14,19 @@ 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("./Middleware"), exports);
-__exportStar(require("./Scope"), exports);
-__exportStar(require("./Role"), exports);
+__exportStar(require("./HyperService"), exports);
 __exportStar(require("./Routes"), exports);
-__exportStar(require("./types"), 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: (abstract new (...args: any[]) => any) | 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/{exeptions → lib/server/exeptions}/HyperException.d.ts

@@ -2,6 +2,7 @@ import { ExceptionType } from "./types";
 export default class HyperException extends Error {
     code: ExceptionType;
     additionalInfo: any;
-    constructor(message: string, 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/{exeptions → lib/server/exeptions}/HyperException.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class HyperException extends Error {
-    constructor(message, code = "HyperException", additionalInfo = {}) {
+    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);

package/dist/{exeptions → lib/server/exeptions}/HyperFileException.js

@@ -6,7 +6,7 @@ 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);
+        super(message, "HyperFileException", additional, 400);
     }
 }
 exports.default = HyperFileException;

package/dist/{exeptions → lib/server/exeptions}/NotRoleException.js

@@ -9,7 +9,7 @@ class NotRoleException extends HyperException_1.default {
         super(message, "NotRoleException", {
             roles,
             requiredRoles,
-        });
+        }, 403);
         this.roles = roles;
         this.requiredRoles = requiredRoles;
     }

package/dist/{exeptions → lib/server/exeptions}/NotScopeException.js

@@ -9,7 +9,7 @@ class NotScopeException extends HyperException_1.default {
         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;

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
+    };
+}

package/dist/type.d.ts

@@ -1,10 +1,21 @@
 import type { Server } from "hyper-express";
+declare module "hyper-express" {
+    interface Request {
+        setValue(key: string, value: any): void;
+        getValue<T>(key: string, defaultValue?: T): T;
+    }
+}
+import { TransformerInput } from "./__internals/transform/transform.registry";
 export type HyperRoleOptions = string | string[];
 export type HyperScopeOptions = string | string[];
 export interface IHyperApplication extends Partial<Server> {
-    onPrepare(): void;
+    onPrepare?(): void;
+    emit?(topic: string, data: any): Promise<void>;
 }
-export type IHyperApp<T> = T & Server;
+export type IHyperApp<T> = T & Server & {
+    emit(topic: string, data: any): Promise<void>;
+    useTransform(transformer: TransformerInput): IHyperApp<T>;
+};
 export interface IHyperAppTarget {
     new (...args: any[]): IHyperApplication;
 }

package/hyper-express-decorators.d.ts

@@ -6,6 +6,7 @@ declare module "hyper-express" {
 
     getScopes(): string[] | undefined;
     setScopes(scopes: HyperScopeOptions): void;
+    setFullScopes(): void
 
     getRoles(): string[] | undefined;
     setRole(role: HyperRoleOptions): void;