@zenofolio/hyper-decor 1.0.7 → 1.0.8

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

@@ -0,0 +1,6 @@
+import { HyperModuleMetadata, Constructor } from "./types";
+/**
+ * 🚀 HyperModule Decorator
+ * Purely injects metadata into the target class.
+ */
+export declare function HyperModule(options: HyperModuleMetadata): (Target: Constructor) => void;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperModule = HyperModule;
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 HyperModule Decorator
+ * Purely injects metadata into the target class.
+ */
+function HyperModule(options) {
+    return (Target) => {
+        metadata_1.HyperMeta.set(Target, undefined, Object.assign({ type: "module" }, options));
+    };
+}

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

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+import { Constructor } from "./types";
+interface ServiceDecoratorOptions {
+    singleton?: boolean;
+    token?: string | symbol | Constructor | (abstract new (...args: any[]) => any);
+}
+/**
+ * 🚀 HyperService Decorator
+ * Purely injects metadata and registers the class in the DI container.
+ */
+export declare function HyperService({ token, singleton, }?: ServiceDecoratorOptions): (Target: any) => any;
+export {};

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

@@ -2,24 +2,17 @@ import "reflect-metadata";
 import { MiddlewareHandler } from "hyper-express";
 import { MiddlewareType } from "./types";
 /**
- * Middleware decorator to attach middleware to controllers, modules, and routes.
+ * 🚀 Middleware Decorator
+ * Purely injects middleware metadata into the target class or method.
  */
 export declare const Middleware: {
-    (...middleware: MiddlewareType[]): ClassDecorator & MethodDecorator;
+    (...middleware: MiddlewareType[]): any;
     /**
      * Exclude middleware from matching paths.
-     *
-     * @param expressions
-     * @param middleware
-     * @returns
      */
-    exclude(expressions: RegExp | RegExp[], middleware: MiddlewareHandler): ClassDecorator & MethodDecorator;
+    exclude(expressions: RegExp | RegExp[], middleware: MiddlewareHandler): any;
     /**
      * Only run middleware on matching paths.
-     *
-     * @param expresiosn
-     * @param middleware
-     * @returns
      */
-    only(expressions: RegExp | RegExp[], middleware: MiddlewareHandler): (Target: any, propertyKey?: any) => void;
+    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/{decorators → lib/server/decorators}/index.d.ts

@@ -1,13 +1,15 @@
+export * from "./metadata";
+export * from "./types";
 export * from "./HyperApp";
 export * from "./HyperModule";
 export * from "./HyperController";
 export * from "./HyperService";
-export * from "./Middleware";
-export * from "./Scope";
-export * from "./Role";
 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";

package/dist/{decorators → lib/server/decorators}/index.js

@@ -14,16 +14,18 @@ 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("./Middleware"), exports);
-__exportStar(require("./Scope"), exports);
-__exportStar(require("./Role"), 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);

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

@@ -1,15 +1,15 @@
 import type { MiddlewareHandler, MiddlewareNext, Request, Response, ServerConstructorOptions } from "hyper-express";
 import { InjectionToken, RegistrationOptions } from "tsyringe";
-import { IMessageTransport } from "../common/transport";
+import { IMessageTransport } from "../../../common/transport";
 export interface OnInit {
     onInit(): Promise<any>;
 }
 export interface IsSingleton {
     isSingleton(): boolean;
 }
-export type Constructor<R extends any = any> = new (...args: any[]) => R;
+export type Constructor<R = object> = new (...args: any[]) => R;
 export type ImportObject = {
-    token: InjectionToken;
+    token: (abstract new (...args: any[]) => any) | InjectionToken;
     useClass?: Constructor;
     useValue?: any;
     useFactory?: (...args: any[]) => any;
@@ -25,6 +25,7 @@ export interface LogSpaces {
     controllers: boolean;
     middleware: boolean;
     routes: boolean;
+    messaging: boolean;
 }
 export interface IHyperHooks {
     onBeforeInit?(instance: any, token: any, context: any): void | Promise<void>;
@@ -42,6 +43,7 @@ export interface HyperAppMetadata {
     modules: Constructor[];
     imports?: ImportType[];
     options?: ServerConstructorOptions;
+    uwsOptions?: any;
     transports?: IMessageTransport[];
     hooks?: IHyperHooks | Constructor<IHyperHooks>;
 }
@@ -67,16 +69,17 @@ export type HyperControllerMetadata = {
 export type HyperControllerDecorator = HyperClassDecorator<HyperControllerMetadata | string>;
 export type ParameterResolver = (req: Request, res: Response) => any | Promise<any>;
 export type HyperParameterMetadata = {
-    params: Record<string, {
+    params: {
         index: number;
-        type: any;
-        key: string;
-        name: string;
-        method: string;
-        resolver: ParameterResolver;
-        schema?: any;
+        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> = {
@@ -101,15 +104,13 @@ export type ScopeMap<T extends string = string> = {
 export type ScopeType<T extends string = string> = T | T[] | ScopeMap<T> | ScopeMap<T>[];
 /**
  * Type definition for Route metadata.
- * Contains method, path, and handler function name.
+ * Contains method, path, and other configuration for a specific method.
  */
 export interface RouteMetadata {
-    className: string;
     method: string;
     path: string;
     propertyKey: string;
-    options?: any;
-    handler: (...args: any[]) => any;
+    options?: Record<string, unknown>;
 }
 export declare abstract class MiddlewareClass {
     abstract handle(req: Request, res: Response, next: MiddlewareNext): void;

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/{__internals/helpers/tree.helper.d.ts → lib/tree/tree.d.ts}

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