@zenofolio/hyper-decor 1.0.4 → 1.0.8

package/dist/lib/openapi/types.d.ts

@@ -0,0 +1,131 @@
+export interface OpenAPIDocument {
+    openapi: string;
+    info: Info;
+    paths: Paths;
+    components?: Components;
+    security?: SecurityRequirement[];
+    tags?: Tag[];
+}
+export interface Info {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: Contact;
+    license?: License;
+    version: string;
+}
+export interface Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface License {
+    name: string;
+    url?: string;
+}
+export interface Paths {
+    [path: string]: PathItem;
+}
+export interface PathItem {
+    get?: Operation;
+    post?: Operation;
+    put?: Operation;
+    delete?: Operation;
+    patch?: Operation;
+    head?: Operation;
+    options?: Operation;
+    trace?: Operation;
+}
+export interface Operation {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    tags?: Tag[];
+    parameters?: OpenApiParameter[];
+    requestBody?: RequestBody;
+    responses: OpenApiResponses;
+    security?: SecurityRequirement[];
+}
+export interface OpenApiParameter {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    schema: Schema;
+}
+export interface RequestBody {
+    description?: string;
+    content: {
+        [mediaType: string]: MediaType;
+    };
+}
+export interface MediaType {
+    schema: Schema;
+}
+export interface OpenApiResponses {
+    [statusCode: string]: OpenApiResponse;
+}
+export interface OpenApiResponse {
+    description: string;
+    content?: {
+        [mediaType: string]: MediaType;
+    };
+    headers?: {
+        [name: string]: Header;
+    };
+}
+export interface Header {
+    description?: string;
+    required?: boolean;
+    schema: Schema;
+}
+export interface Schema {
+    type: string;
+    format?: string;
+    items?: Schema;
+    properties?: {
+        [key: string]: Schema;
+    };
+    additionalProperties?: boolean;
+    example?: any;
+}
+export interface SecurityRequirement {
+    [securityScheme: string]: string[];
+}
+export interface Tag {
+    name: string;
+    description?: string;
+}
+export interface Components {
+    schemas?: {
+        [schemaName: string]: Schema;
+    };
+    responses?: {
+        [responseName: string]: OpenApiResponse;
+    };
+    parameters?: {
+        [parameterName: string]: OpenApiParameter;
+    };
+    securitySchemes?: {
+        [schemeName: string]: SecurityScheme;
+    };
+}
+export interface SecurityScheme {
+    type: "apiKey" | "http" | "oauth2" | "openIdConnect";
+    in?: "header" | "query" | "cookie";
+    name?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    openIdConnectUrl?: string;
+    oauth2?: OAuth2Scheme;
+}
+export interface OAuth2Scheme {
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshUrl?: string;
+    scopes: {
+        [scope: string]: string;
+    };
+}

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

@@ -0,0 +1,37 @@
+import { Request } from "hyper-express/types";
+/**
+ * File upload restrictions
+ */
+export interface FileUploadRestrictions {
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+}
+/**
+ * File restrictions resolver
+ */
+export type FileRestrictions = FileUploadRestrictions | ((request: Request) => FileUploadRestrictions | Promise<FileUploadRestrictions>);
+/**
+ * File decorator options
+ */
+export interface FileOptions {
+    fieldName: string | string[];
+    restrictions?: FileRestrictions;
+    required?: boolean;
+}
+export interface UploadedFile {
+    field: string;
+    name: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    extension: string;
+    buffer: Buffer;
+}
+/**
+ * Decorator to extract file from the request
+ */
+export declare const File: {
+    (options: FileOptions | string): (target: object, propertyKey: string | symbol, index: number) => void;
+    options(options: FileOptions, required?: boolean): (fieldName: string | string[]) => (target: object, propertyKey: string | symbol, index: number) => void;
+    restrictions(restrictions: FileRestrictions): (fieldName: string | string[], required?: boolean) => (target: object, propertyKey: string | symbol, index: number) => void;
+};

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

@@ -8,46 +8,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.File = void 0;
 const Http_1 = require("./Http");
-const consumers_1 = require("stream/consumers");
 const HyperFileException_1 = __importDefault(require("../exeptions/HyperFileException"));
 /**
  * Decorator to extract file from the request
- *
- * @param param0
  */
 const File = (options) => {
     const _options = typeof options === "string" ? { fieldName: options } : options;
     return (0, Http_1.createCustomRequestDecorator)("File", (request) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
         const { allowedMimeTypes, maxFileSize } = yield resolveRestrictions(request, _options.restrictions);
         const passTypes = allowedMimeTypes.includes("*") || allowedMimeTypes.length === 0;
         const passSize = maxFileSize === Infinity;
         const contentType = (_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-type"];
-        const fileSize = Number((_b = request.headers) === null || _b === void 0 ? void 0 : _b["content-length"]);
         const isMultipart = contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data");
         if (!isMultipart) {
             throw new HyperFileException_1.default("Invalid request, expected multipart form data", {
                 fieldName: _options.fieldName,
             });
         }
-        if (isNaN(fileSize) || fileSize <= 0) {
-            throw new HyperFileException_1.default(`File ${_options.fieldName} is missing or empty`, {
-                fieldName: _options.fieldName,
-                fileSize,
-            });
-        }
-        if (!passSize && fileSize > maxFileSize) {
-            throw new HyperFileException_1.default(`File ${_options.fieldName} is too large. Max size is ${maxFileSize} bytes`, {
-                fieldName: _options.fieldName,
-                maxFileSize,
-            });
-        }
         const files = yield extractFiles(request, {
             maxSize: passSize ? undefined : maxFileSize,
             mimeTypes: passTypes ? undefined : allowedMimeTypes,
@@ -64,35 +55,16 @@ const File = (options) => {
     }));
 };
 exports.File = File;
-/**
- *
- * Helper function to create a file decorator with options
- *
- * @param options
- * @returns
- */
 exports.File.options = (options, required = false) => {
     return (fieldName) => {
         return (0, exports.File)(Object.assign(Object.assign({}, options), { required, fieldName }));
     };
 };
-/**
- * Helper function to create a file decorator with restrictions
- *
- * @param restrictions
- * @returns
- */
 exports.File.restrictions = (restrictions) => {
     return (fieldName, required = false) => {
         return (0, exports.File)({ fieldName, restrictions, required });
     };
 };
-/////////////////////////////
-// Types
-/////////////////////////////
-/////////////////////////////
-/// Utility
-/////////////////////////////
 const resolveRestrictions = (request, restrictions) => __awaiter(void 0, void 0, void 0, function* () {
     if (typeof restrictions === "function") {
         return yield restrictions(request);
@@ -103,63 +75,78 @@ const resolveRestrictions = (request, restrictions) => __awaiter(void 0, void 0,
     });
 });
 /**
- * Extract files from a request with validation, transformation, and required files check.
- *
- * @param request
- * @param options Validation and transformation options
- * @returns Transformed or raw file details
+ * Extract files from a request with validation and secure streaming.
  */
 const extractFiles = (request, options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    const contentType = (_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-type"];
-    if (!(contentType === null || contentType === void 0 ? void 0 : contentType.includes("multipart/form-data"))) {
-        throw new Error("Invalid request, expected multipart form data");
-    }
     const filesMap = {};
+    // Track if we are already over total limit (Content-Length check as first line of defense)
+    const totalLength = Number((_a = request.headers) === null || _a === void 0 ? void 0 : _a["content-length"]);
+    if ((options === null || options === void 0 ? void 0 : options.maxSize) && !isNaN(totalLength) && totalLength > options.maxSize + 1024 * 10) { // Buffer for boundaries
+        // Content-Length is significantly larger than allowed file size
+        // We don't throw yet because multipart might have multiple files or large fields
+    }
     yield request.multipart((field) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
+        var _a, e_1, _b, _c;
+        var _d, _e;
         if (field.file && field.file.stream) {
-            const bufferFile = yield (0, consumers_1.buffer)(field.file.stream);
-            const type = yield (yield import("file-type")).fileTypeFromBuffer(bufferFile);
-            if (!type) {
-                throw new HyperFileException_1.default(`Invalid file type`, {
-                    field: field.name,
-                });
+            const chunks = [];
+            let totalRead = 0;
+            try {
+                // Safe stream reading with early exit
+                for (var _f = true, _g = __asyncValues(field.file.stream), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                    _c = _h.value;
+                    _f = false;
+                    const chunk = _c;
+                    totalRead += chunk.length;
+                    if ((options === null || options === void 0 ? void 0 : options.maxSize) && totalRead > options.maxSize) {
+                        throw new HyperFileException_1.default(`File '${field.name}' exceeds the maximum limit of ${options.maxSize} bytes`, { field: field.name, maxSize: options.maxSize });
+                    }
+                    chunks.push(chunk);
+                }
             }
-            const mimeType = type.mime;
-            const extention = type.ext;
-            // Validate MIME type early
-            if ((options === null || options === void 0 ? void 0 : options.mimeTypes) && !options.mimeTypes.includes(mimeType)) {
-                throw new HyperFileException_1.default(`Invalid file type, only ${options.mimeTypes.join(", ")} is allowed`, {
-                    field: field.name,
-                    allowedMimeTypes: options.mimeTypes,
-                    mimeType,
-                });
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
-            if (!type) {
-                throw new HyperFileException_1.default(`Invalid file type`, {
-                    field: field.name,
-                });
+            const bufferFile = Buffer.concat(chunks);
+            const { fileTypeFromBuffer } = yield import("file-type");
+            const type = yield fileTypeFromBuffer(bufferFile);
+            const mimeType = (type === null || type === void 0 ? void 0 : type.mime) || "unknown/unrecognized";
+            const extension = (type === null || type === void 0 ? void 0 : type.ext) || "bin";
+            // Validate MIME type early if unrecognized
+            if (!type && (options === null || options === void 0 ? void 0 : options.mimeTypes) && options.mimeTypes.length > 0) {
+                throw new HyperFileException_1.default(`Invalid file type for field '${field.name}'. Could not recognize file signature. Expected one of: ${options.mimeTypes.join(", ")}`, { field: field.name, allowedMimeTypes: options.mimeTypes });
             }
-            if ((options === null || options === void 0 ? void 0 : options.maxSize) && bufferFile.byteLength > options.maxSize) {
-                throw new HyperFileException_1.default(`File '${field.name}' size exceeds the maximum limit of ${options.maxSize} bytes`, {
+            // Validate MIME type if recognized
+            if ((options === null || options === void 0 ? void 0 : options.mimeTypes) && !options.mimeTypes.includes(mimeType)) {
+                throw new HyperFileException_1.default(`Invalid file type for field '${field.name}'. Expected: ${options.mimeTypes.join(", ")}, Received: ${mimeType}`, {
                     field: field.name,
-                    maxSize: options.maxSize,
+                    allowedMimeTypes: options.mimeTypes,
+                    receivedMimeType: mimeType,
                 });
             }
-            if ((options === null || options === void 0 ? void 0 : options.requireName) && !((_a = field.file) === null || _a === void 0 ? void 0 : _a.name)) {
-                throw new HyperFileException_1.default(`File name is required`, {
+            if ((options === null || options === void 0 ? void 0 : options.requireName) && !((_d = field.file) === null || _d === void 0 ? void 0 : _d.name)) {
+                throw new HyperFileException_1.default(`File name is required for field '${field.name}'`, {
                     field: field.name,
                 });
             }
-            // Derive file details
-            const name = (_d = (_c = (_b = field.file) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.split(".").shift()) !== null && _d !== void 0 ? _d : field.name;
-            const filename = `${name === null || name === void 0 ? void 0 : name.replace(extention, "")}.${extention}`;
+            // Secure filename resolution
+            const rawName = ((_e = field.file) === null || _e === void 0 ? void 0 : _e.name) || field.name;
+            // Sanitize: remove null bytes, path traversal sequences, and extract base name
+            const sanitizedBase = rawName.replace(/\0/g, "").split(/[\\/]/).pop() || "file";
+            const nameOnly = sanitizedBase.includes(".")
+                ? sanitizedBase.substring(0, sanitizedBase.lastIndexOf("."))
+                : sanitizedBase;
+            const filename = `${nameOnly}.${extension}`;
             filesMap[field.name] = {
                 field: field.name,
-                name: name,
+                name: nameOnly,
                 filename: filename,
-                ext: extention,
+                extension: extension,
                 size: bufferFile.byteLength,
                 mimeType: mimeType,
                 buffer: bufferFile,

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

@@ -0,0 +1,12 @@
+import { ParameterResolver } from "./types";
+/**
+ * 🛠️ Helper to create parameter decorators
+ */
+export declare function createParamDecorator(source: "body" | "query" | "params" | "headers" | "req" | "res", decorator: string, keyOrSchema?: string | object | Function, schemaOrTransform?: object | Function, isWholeSource?: boolean, customResolver?: ParameterResolver): (target: object, propertyKey: string | symbol, index: number) => void;
+export declare function Query(keyOrSchema?: string | object | Function, schemaOrTransform?: object | Function): (target: object, propertyKey: string | symbol, index: number) => void;
+export declare function Body(keyOrSchema?: string | object | Function, schemaOrTransform?: object | Function): (target: object, propertyKey: string | symbol, index: number) => void;
+export declare function Param(keyOrSchema: string | object | Function, schemaOrTransform?: object | Function): (target: object, propertyKey: string | symbol, index: number) => void;
+export declare function Headers(keyOrSchema?: string | object | Function, schemaOrTransform?: object | Function): (target: object, propertyKey: string | symbol, index: number) => void;
+export declare const Req: () => (target: object, propertyKey: string | symbol, index: number) => void;
+export declare const Res: () => (target: object, propertyKey: string | symbol, index: number) => void;
+export declare const createCustomRequestDecorator: (decoratorName: string, resolver: ParameterResolver) => (target: object, propertyKey: string | symbol, index: number) => void;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCustomRequestDecorator = exports.Res = exports.Req = void 0;
+exports.createParamDecorator = createParamDecorator;
+exports.Query = Query;
+exports.Body = Body;
+exports.Param = Param;
+exports.Headers = Headers;
+const metadata_1 = require("./metadata");
+/**
+ * 🛠️ Helper to create parameter decorators
+ */
+function createParamDecorator(source, decorator, keyOrSchema, schemaOrTransform, isWholeSource = false, customResolver) {
+    return (target, propertyKey, index) => {
+        var _a;
+        const root = metadata_1.HyperMeta.get(target, propertyKey);
+        const params = ((_a = root.params) === null || _a === void 0 ? void 0 : _a.params) || [];
+        const picker = typeof keyOrSchema === 'string' ? keyOrSchema : undefined;
+        const schema = (typeof keyOrSchema === 'object' || typeof keyOrSchema === 'function')
+            ? keyOrSchema
+            : schemaOrTransform;
+        params.push({
+            index,
+            type: (Reflect.getMetadata("design:paramtypes", target, propertyKey) || [])[index],
+            source,
+            picker,
+            schema,
+            isWholeSource: isWholeSource || (picker === undefined && keyOrSchema !== undefined),
+            decorator,
+            resolver: customResolver,
+        });
+        metadata_1.HyperMeta.set(target, propertyKey, {
+            params: { params }
+        });
+    };
+}
+function Query(keyOrSchema, schemaOrTransform) {
+    return createParamDecorator("query", "Query", keyOrSchema, schemaOrTransform);
+}
+function Body(keyOrSchema, schemaOrTransform) {
+    return createParamDecorator("body", "Body", keyOrSchema, schemaOrTransform);
+}
+function Param(keyOrSchema, schemaOrTransform) {
+    return createParamDecorator("params", "Param", keyOrSchema, schemaOrTransform);
+}
+function Headers(keyOrSchema, schemaOrTransform) {
+    return createParamDecorator("headers", "Headers", keyOrSchema, schemaOrTransform);
+}
+const Req = () => createParamDecorator("req", "Req", undefined, undefined, true, (req) => req);
+exports.Req = Req;
+const Res = () => createParamDecorator("res", "Res", undefined, undefined, true, (_req, res) => res);
+exports.Res = Res;
+const createCustomRequestDecorator = (decoratorName, resolver) => {
+    return createParamDecorator("req", decoratorName, undefined, undefined, true, resolver);
+};
+exports.createCustomRequestDecorator = createCustomRequestDecorator;

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

@@ -0,0 +1,7 @@
+import { HyperAppMetadata, Constructor } from "./types";
+/**
+ * 🚀 HyperApp Decorator
+ * Purely injects metadata and a prepare method into the target class.
+ * No class wrapping or modification of the original constructor.
+ */
+export declare function HyperApp(options: HyperAppMetadata): (Target: Constructor) => void;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperApp = HyperApp;
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 HyperApp Decorator
+ * Purely injects metadata and a prepare method into the target class.
+ * No class wrapping or modification of the original constructor.
+ */
+function HyperApp(options) {
+    return (Target) => {
+        metadata_1.HyperMeta.set(Target, undefined, Object.assign({ type: "app" }, options));
+    };
+}

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperController = HyperController;
+const metadata_1 = require("./metadata");
+/**
+ * 🚀 HyperController Decorator
+ * Purely injects metadata into the target class.
+ */
+function HyperController(options) {
+    return (Target) => {
+        const isString = typeof options === "string";
+        const data = isString ? { path: options } : (options !== null && options !== void 0 ? options : {});
+        metadata_1.HyperMeta.set(Target, undefined, Object.assign({ type: "controller" }, data));
+    };
+}

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