@zenofolio/hyper-decor 1.0.71 → 1.0.73

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperService = HyperService;
+require("reflect-metadata");
+const tsyringe_1 = require("tsyringe");
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 HyperService Decorator
+ * Purely injects metadata and registers the class in the DI container.
+ */
+function HyperService({ token, singleton = true, } = {}) {
+    return (Target) => {
+        const useToken = token !== null && token !== void 0 ? token : Target;
+        // 1. DI Registration
+        (0, tsyringe_1.injectable)()(Target);
+        if (!tsyringe_1.container.isRegistered(useToken)) {
+            if (singleton) {
+                tsyringe_1.container.registerSingleton(useToken, Target);
+            }
+            else {
+                tsyringe_1.container.register(useToken, { useClass: Target });
+            }
+        }
+        // 2. Hierarchical Metadata Injection
+        metadata_1.HyperMeta.set(Target, undefined, {
+            type: 'service',
+        });
+        return Target;
+    };
+}

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

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+/**
+ * 🚀 OnMessage Decorator
+ * Purely injects message subscription metadata into the method.
+ *
+ * @param topic The topic or pattern to listen to (e.g. "user.created", "user.*")
+ */
+export declare const OnMessage: (topic: string) => (target: any, propertyKey: any) => void;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnMessage = void 0;
+require("reflect-metadata");
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 OnMessage Decorator
+ * Purely injects message subscription metadata into the method.
+ *
+ * @param topic The topic or pattern to listen to (e.g. "user.created", "user.*")
+ */
+const OnMessage = (topic) => {
+    return (target, propertyKey) => {
+        metadata_1.HyperMeta.set(target, propertyKey, {
+            onMessage: { topic }
+        });
+    };
+};
+exports.OnMessage = OnMessage;

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

@@ -0,0 +1,18 @@
+import "reflect-metadata";
+import { MiddlewareHandler } from "hyper-express";
+import { MiddlewareType } from "./types";
+/**
+ * 🚀 Middleware Decorator
+ * Purely injects middleware metadata into the target class or method.
+ */
+export declare const Middleware: {
+    (...middleware: MiddlewareType[]): any;
+    /**
+     * Exclude middleware from matching paths.
+     */
+    exclude(expressions: RegExp | RegExp[], middleware: MiddlewareHandler): any;
+    /**
+     * Only run middleware on matching paths.
+     */
+    only(expressions: RegExp | RegExp[], middleware: MiddlewareHandler): any;
+};

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/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[]);
+}