@venok/http 1.0.1-canary.0

package/context/context.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+import { Observable } from "rxjs";
+import { CustomHeader, RedirectResponse } from "./response.controller";
+import { RequestMethod, RouteParamtypes } from "../enums";
+import { VenokContextCreator } from "@venok/core/context";
+import { ContextId, ContextType, PipeTransform } from "@venok/core";
+import { HeaderStream } from "../helpers";
+import { HttpServer } from "../interfaces";
+import { RouterExceptionFiltersContext } from "../filters/context";
+import { ParamData } from "../decorators";
+export interface ParamProperties {
+    index: number;
+    type: RouteParamtypes | string;
+    data: ParamData;
+    pipes: PipeTransform[];
+    extractValue: <TRequest, TResponse>(req: TRequest, res: TResponse, next: Function) => any;
+}
+export type HandleResponseFn = HandlerResponseBasicFn | HandleSseResponseFn;
+export type HandlerResponseBasicFn = <TResult, TResponse>(result: TResult, res: TResponse, req?: any) => any;
+export type HandleSseResponseFn = <TResult extends Observable<unknown> = any, TResponse extends HeaderStream = any, TRequest extends IncomingMessage = any>(result: TResult, res: TResponse, req: TRequest) => any;
+export interface HandlerMetadata {
+    argsLength: number;
+    paramtypes: any[];
+    httpStatusCode: number;
+    responseHeaders: any[];
+    hasCustomHeaders: boolean;
+    getParamsMetadata: (moduleKey: string, contextId?: ContextId, inquirerId?: string) => (ParamProperties & {
+        metatype?: any;
+    })[];
+    fnHandleResponse: HandleResponseFn;
+}
+export interface IRouteParamsFactory {
+    exchangeKeyForValue<TRequest extends Record<string, any> = any, TResponse = any, TResult = any>(key: RouteParamtypes | string, data: any, args: [TRequest, TResponse, Function]): TResult;
+}
+export declare class HttpContextCreator {
+    private readonly venokContextCreator;
+    private readonly exceptionsFilter;
+    private readonly applicationRef;
+    private readonly responseController;
+    constructor(venokContextCreator: VenokContextCreator, exceptionsFilter: RouterExceptionFiltersContext, applicationRef: HttpServer);
+    create(instance: Object, callback: (...args: any[]) => unknown, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextId?: ContextId, inquirerId?: string): (...args: any[]) => Promise<any>;
+    getMetadata<TContext extends ContextType = ContextType>(instance: Object, callback: (...args: any[]) => any, methodName: string, moduleKey: string, requestMethod: RequestMethod, contextType: TContext): {
+        fnHandleResponse: HandleResponseFn;
+        httpStatusCode: number;
+        hasCustomHeaders: boolean;
+        responseHeaders: CustomHeader[];
+    };
+    reflectRedirect(callback: (...args: unknown[]) => unknown): RedirectResponse;
+    reflectHttpStatusCode(callback: (...args: unknown[]) => unknown): number;
+    reflectRenderTemplate(callback: (...args: unknown[]) => unknown): string;
+    reflectResponseHeaders(callback: (...args: unknown[]) => unknown): CustomHeader[];
+    reflectSse(callback: (...args: unknown[]) => unknown): string;
+    createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandleResponseFn;
+    private isResponseHandled;
+}

package/context/context.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpContextCreator = void 0;
+const response_controller_1 = require("./response.controller");
+const constants_1 = require("../constants");
+const enums_1 = require("../enums");
+const constants_2 = require("../../core/injector/constants");
+const constants_3 = require("../../core/constants");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const factory_1 = require("../factory");
+class HttpContextCreator {
+    constructor(venokContextCreator, exceptionsFilter, applicationRef) {
+        this.venokContextCreator = venokContextCreator;
+        this.exceptionsFilter = exceptionsFilter;
+        this.applicationRef = applicationRef;
+        this.responseController = new response_controller_1.RouterResponseController(applicationRef);
+    }
+    create(instance, callback, methodName, moduleKey, requestMethod, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const contextType = "http";
+        const { fnHandleResponse, httpStatusCode, responseHeaders, hasCustomHeaders } = this.getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType);
+        const doneCallback = async (result, req, res, next) => {
+            this.responseController.setStatus(res, httpStatusCode);
+            hasCustomHeaders && this.responseController.setHeaders(res, responseHeaders);
+            await fnHandleResponse(result, res, req);
+        };
+        const result = this.venokContextCreator.create(instance, callback, methodName, constants_3.ROUTE_ARGS_METADATA, new factory_1.RouteParamsFactory(), contextId, inquirerId, {
+            guards: true,
+            interceptors: true,
+            filters: false,
+            callback: doneCallback,
+        }, contextType);
+        const exceptionFilter = this.exceptionsFilter.create(instance, callback, moduleKey, contextId, inquirerId);
+        return this.venokContextCreator.venokProxy.createProxy(result, exceptionFilter);
+    }
+    getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType) {
+        const metadata = this.venokContextCreator.contextUtils.reflectCallbackMetadata(instance, methodName, constants_3.ROUTE_ARGS_METADATA) || {};
+        const keys = Object.keys(metadata);
+        const contextFactory = this.venokContextCreator.contextUtils.getContextFactory(contextType, instance, callback);
+        const getParamsMetadata = (moduleKey, contextId = constants_2.STATIC_CONTEXT, inquirerId) => this.venokContextCreator.exchangeKeysForValues(keys, metadata, moduleKey, new factory_1.RouteParamsFactory(), contextId, inquirerId, contextFactory);
+        const paramsMetadata = getParamsMetadata(moduleKey);
+        const isResponseHandled = this.isResponseHandled(instance, methodName, paramsMetadata);
+        const httpRedirectResponse = this.reflectRedirect(callback);
+        const fnHandleResponse = this.createHandleResponseFn(callback, isResponseHandled, httpRedirectResponse);
+        const httpCode = this.reflectHttpStatusCode(callback);
+        const httpStatusCode = httpCode ? httpCode : this.responseController.getStatusByMethod(requestMethod);
+        const responseHeaders = this.reflectResponseHeaders(callback);
+        const hasCustomHeaders = !(0, shared_helper_1.isEmpty)(responseHeaders);
+        return {
+            fnHandleResponse,
+            httpStatusCode,
+            hasCustomHeaders,
+            responseHeaders,
+        };
+    }
+    reflectRedirect(callback) {
+        return Reflect.getMetadata(constants_1.REDIRECT_METADATA, callback);
+    }
+    reflectHttpStatusCode(callback) {
+        return Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, callback);
+    }
+    reflectRenderTemplate(callback) {
+        return Reflect.getMetadata(constants_1.RENDER_METADATA, callback);
+    }
+    reflectResponseHeaders(callback) {
+        return Reflect.getMetadata(constants_1.HEADERS_METADATA, callback) || [];
+    }
+    reflectSse(callback) {
+        return Reflect.getMetadata(constants_1.SSE_METADATA, callback);
+    }
+    createHandleResponseFn(callback, isResponseHandled, redirectResponse, httpStatusCode) {
+        const renderTemplate = this.reflectRenderTemplate(callback);
+        if (renderTemplate) {
+            return async (result, res) => {
+                return await this.responseController.render(result, res, renderTemplate);
+            };
+        }
+        if (redirectResponse && (0, shared_helper_1.isString)(redirectResponse.url)) {
+            return async (result, res) => {
+                await this.responseController.redirect(result, res, redirectResponse);
+            };
+        }
+        const isSseHandler = !!this.reflectSse(callback);
+        if (isSseHandler) {
+            return (result, res, req) => {
+                this.responseController.sse(result, res.raw || res, req.raw || req, {
+                    additionalHeaders: res.getHeaders?.(),
+                });
+            };
+        }
+        return async (result, res) => {
+            result = await this.responseController.transformToResult(result);
+            !isResponseHandled && (await this.responseController.apply(result, res, httpStatusCode));
+            return res;
+        };
+    }
+    isResponseHandled(instance, methodName, paramsMetadata) {
+        const hasResponseOrNextDecorator = paramsMetadata.some(({ type }) => type === enums_1.RouteParamtypes.RESPONSE || type === enums_1.RouteParamtypes.NEXT);
+        const isPassthroughEnabled = Reflect.getMetadata(constants_1.RESPONSE_PASSTHROUGH_METADATA, instance.constructor, methodName);
+        return hasResponseOrNextDecorator && !isPassthroughEnabled;
+    }
+}
+exports.HttpContextCreator = HttpContextCreator;

package/context/response.controller.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { Observable } from "rxjs";
+import { IncomingMessage } from "http";
+import { AdditionalHeaders, WritableHeaderStream } from "../helpers";
+import { HttpServer } from "../interfaces/http/server.interface";
+import { RequestMethod } from "../enums";
+export interface CustomHeader {
+    name: string;
+    value: string;
+}
+export interface RedirectResponse {
+    url: string;
+    statusCode?: number;
+}
+export declare class RouterResponseController {
+    private readonly applicationRef;
+    private readonly logger;
+    constructor(applicationRef: HttpServer);
+    apply<TInput = any, TResponse = any>(result: TInput, response: TResponse, httpStatusCode?: number): Promise<any>;
+    redirect<TInput = any, TResponse = any>(resultOrDeferred: TInput, response: TResponse, redirectResponse: RedirectResponse): Promise<void>;
+    render<TInput = unknown, TResponse = unknown>(resultOrDeferred: TInput, response: TResponse, template: string): Promise<any>;
+    transformToResult(resultOrDeferred: any): Promise<any>;
+    getStatusByMethod(requestMethod: RequestMethod): number;
+    setHeaders<TResponse = unknown>(response: TResponse, headers: CustomHeader[]): void;
+    setStatus<TResponse = unknown>(response: TResponse, statusCode: number): void;
+    sse<TInput extends Observable<unknown> = any, TResponse extends WritableHeaderStream = any, TRequest extends IncomingMessage = any>(result: TInput, response: TResponse, request: TRequest, options?: {
+        additionalHeaders: AdditionalHeaders;
+    }): void;
+    private assertObservable;
+}

package/context/response.controller.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterResponseController = void 0;
+const rxjs_1 = require("rxjs");
+const helpers_1 = require("../helpers");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const logger_service_1 = require("../../core/services/logger.service");
+const enums_1 = require("../enums");
+class RouterResponseController {
+    constructor(applicationRef) {
+        this.applicationRef = applicationRef;
+        this.logger = new logger_service_1.Logger(RouterResponseController.name);
+    }
+    async apply(result, response, httpStatusCode) {
+        return this.applicationRef.reply(response, result, httpStatusCode);
+    }
+    async redirect(resultOrDeferred, response, redirectResponse) {
+        const result = await this.transformToResult(resultOrDeferred);
+        const statusCode = result && result.statusCode
+            ? result.statusCode
+            : redirectResponse.statusCode
+                ? redirectResponse.statusCode
+                : enums_1.HttpStatus.FOUND;
+        const url = result && result.url ? result.url : redirectResponse.url;
+        this.applicationRef.redirect(response, statusCode, url);
+    }
+    async render(resultOrDeferred, response, template) {
+        const result = await this.transformToResult(resultOrDeferred);
+        return this.applicationRef.render(response, template, result);
+    }
+    async transformToResult(resultOrDeferred) {
+        if ((0, rxjs_1.isObservable)(resultOrDeferred)) {
+            return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
+        }
+        return resultOrDeferred;
+    }
+    getStatusByMethod(requestMethod) {
+        switch (requestMethod) {
+            case enums_1.RequestMethod.POST:
+                return enums_1.HttpStatus.CREATED;
+            default:
+                return enums_1.HttpStatus.OK;
+        }
+    }
+    setHeaders(response, headers) {
+        headers.forEach(({ name, value }) => this.applicationRef.setHeader(response, name, value));
+    }
+    setStatus(response, statusCode) {
+        this.applicationRef.status(response, statusCode);
+    }
+    sse(result, response, request, options) {
+        // It's possible that we sent headers already so don't use a stream
+        if (response.writableEnded)
+            return;
+        this.assertObservable(result);
+        const stream = new helpers_1.SseStream(request);
+        stream.pipe(response, options);
+        const subscription = result
+            .pipe((0, rxjs_1.map)((message) => {
+            if ((0, shared_helper_1.isObject)(message))
+                return message;
+            return { data: message };
+        }), (0, rxjs_1.debounce)((message) => new Promise((resolve) => stream.writeMessage(message, () => resolve()))), (0, rxjs_1.catchError)((err) => {
+            const data = err instanceof Error ? err.message : err;
+            stream.writeMessage({ type: "error", data }, (writeError) => {
+                if (writeError)
+                    this.logger.error(writeError);
+            });
+            return rxjs_1.EMPTY;
+        }))
+            .subscribe({
+            complete: () => {
+                response.end();
+            },
+        });
+        request.on("close", () => {
+            subscription.unsubscribe();
+        });
+    }
+    assertObservable(value) {
+        if (!(0, rxjs_1.isObservable)(value)) {
+            throw new ReferenceError("You must return an Observable stream to use Server-Sent Events (SSE).");
+        }
+    }
+}
+exports.RouterResponseController = RouterResponseController;

package/decorators/controller.decorator.d.ts

@@ -0,0 +1,82 @@
+import { ScopeOptions } from "@venok/core";
+import { VersionOptions } from "../interfaces";
+/**
+ * Interface defining options that can be passed to `@Controller()` decorator
+ *
+ * @publicApi
+ */
+export interface ControllerOptions extends ScopeOptions, VersionOptions {
+    /**
+     * Specifies an optional `route path prefix`.  The prefix is pre-pended to the
+     * path specified in any request decorator in the class.
+     *
+     * Supported only by HTTP-based application (does not apply to non-HTTP microservices).
+     */
+    path?: string | string[];
+    /**
+     * Specifies an optional HTTP Request host filter.  When configured, methods
+     * within the controller will only be routed if the request host matches the
+     * specified value.
+     */
+    host?: string | RegExp | Array<string | RegExp>;
+}
+/**
+ * Decorator that marks a class as a Venok controller that can receive inbound
+ * requests and produce responses.
+ *
+ * An HTTP Controller responds to inbound HTTP Requests and produces HTTP Responses.
+ * It defines a class that provides the context for one or more related route
+ * handlers that correspond to HTTP request methods and associated routes
+ * for example `GET /api/profile`, `POST /users/resume`.
+ *
+ * A Microservice Controller responds to requests as well as events, running over
+ * a variety of transports. It defines a class that provides a context for
+ * one or more message or event handlers.
+ *
+ * @publicApi
+ */
+export declare function Controller(): ClassDecorator;
+/**
+ * Decorator that marks a class as a Venok controller that can receive inbound
+ * requests and produce responses.
+ *
+ * An HTTP Controller responds to inbound HTTP Requests and produces HTTP Responses.
+ * It defines a class that provides the context for one or more related route
+ * handlers that correspond to HTTP request methods and associated routes
+ * for example `GET /api/profile`, `POST /users/resume`.
+ *
+ * A Microservice Controller responds to requests as well as events, running over
+ * a variety of transports. It defines a class that provides a context for
+ * one or more message or event handlers.
+ *
+ * @param {string|Array} prefix string that defines a `route path prefix`.  The prefix
+ * is pre-pended to the path specified in any request decorator in the class.
+ *
+ * @publicApi
+ */
+export declare function Controller(prefix: string | string[]): ClassDecorator;
+/**
+ * Decorator that marks a class as a Venok controller that can receive inbound
+ * requests and produce responses.
+ *
+ * An HTTP Controller responds to inbound HTTP Requests and produces HTTP Responses.
+ * It defines a class that provides the context for one or more related route
+ * handlers that correspond to HTTP request methods and associated routes
+ * for example `GET /api/profile`, `POST /users/resume`.
+ *
+ * A Microservice Controller responds to requests as well as events, running over
+ * a variety of transports. It defines a class that provides a context for
+ * one or more message or event handlers.
+ *
+ * @param {object} options configuration object specifying:
+ *
+ * - `scope` - symbol that determines the lifetime of a Controller instance.
+ * See Scope for more details.
+ * - `prefix` - string that defines a `route path prefix`.  The prefix
+ * is pre-pended to the path specified in any request decorator in the class.
+ * - `version` - string, array of strings, or Symbol that defines the version
+ * of all routes in the class. See Versioning for more details.
+ *
+ * @publicApi
+ */
+export declare function Controller(options: ControllerOptions): ClassDecorator;

package/decorators/controller.decorator.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const constants_1 = require("../../core/constants");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const constants_2 = require("@venok/http/constants");
+/**
+ * Decorator that marks a class as a Venok controller that can receive inbound
+ * requests and produce responses.
+ *
+ * An HTTP Controller responds to inbound HTTP Requests and produces HTTP Responses.
+ * It defines a class that provides the context for one or more related route
+ * handlers that correspond to HTTP request methods and associated routes
+ * for example `GET /api/profile`, `POST /users/resume`
+ *
+ * A Microservice Controller responds to requests as well as events, running over
+ * a variety of transports. It defines a class that provides a context for
+ * one or more message or event handlers.
+ *
+ * @param prefixOrOptions a `route path prefix` or a `ControllerOptions` object.
+ * A `route path prefix` is pre-pended to the path specified in any request decorator
+ * in the class. `ControllerOptions` is an options configuration object specifying:
+ * - `scope` - symbol that determines the lifetime of a Controller instance.
+ * See Scope for more details.
+ * - `prefix` - string that defines a `route path prefix`.  The prefix
+ * is pre-pended to the path specified in any request decorator in the class.
+ * - `version` - string, array of strings, or Symbol that defines the version
+ * of all routes in the class. See Versioning
+ * for more details.
+ *
+ * @publicApi
+ */
+function Controller(prefixOrOptions) {
+    const defaultPath = "/";
+    const [path, host, scopeOptions, versionOptions] = (0, shared_helper_1.isUndefined)(prefixOrOptions)
+        ? [defaultPath, undefined, undefined, undefined]
+        : (0, shared_helper_1.isString)(prefixOrOptions) || Array.isArray(prefixOrOptions)
+            ? [prefixOrOptions, undefined, undefined, undefined]
+            : [
+                prefixOrOptions.path || defaultPath,
+                prefixOrOptions.host,
+                { scope: prefixOrOptions.scope, durable: prefixOrOptions.durable },
+                Array.isArray(prefixOrOptions.version) ? Array.from(new Set(prefixOrOptions.version)) : prefixOrOptions.version,
+            ];
+    return (target) => {
+        Reflect.defineMetadata(constants_2.CONTROLLER_WATERMARK, true, target);
+        Reflect.defineMetadata(constants_2.PATH_METADATA, path, target);
+        Reflect.defineMetadata(constants_2.HOST_METADATA, host, target);
+        Reflect.defineMetadata(constants_1.SCOPE_OPTIONS_METADATA, scopeOptions, target);
+        Reflect.defineMetadata(constants_2.VERSION_METADATA, versionOptions, target);
+    };
+}
+exports.Controller = Controller;

package/decorators/header.decorator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Request method Decorator.  Sets a response header.
+ *
+ * For example:
+ * `@Header('Cache-Control', 'none')`
+ *
+ * @param name string to be used for header name
+ * @param value string to be used for header value
+ *
+ * @publicApi
+ */
+export declare function Header(name: string, value: string): MethodDecorator;

package/decorators/header.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Header = void 0;
+const extends_metadata_helper_1 = require("../../core/helpers/extends-metadata.helper");
+const constants_1 = require("@venok/http/constants");
+/**
+ * Request method Decorator.  Sets a response header.
+ *
+ * For example:
+ * `@Header('Cache-Control', 'none')`
+ *
+ * @param name string to be used for header name
+ * @param value string to be used for header value
+ *
+ * @publicApi
+ */
+function Header(name, value) {
+    return (target, key, descriptor) => {
+        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.HEADERS_METADATA, [{ name, value }], descriptor.value);
+        return descriptor;
+    };
+}
+exports.Header = Header;

package/decorators/http-code.decorator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Request method Decorator. Defines the HTTP response status code.  Overrides
+ * default status code for the decorated request method.
+ *
+ * @param statusCode HTTP response code to be returned by route handler.
+ *
+ * @publicApi
+ */
+export declare function HttpCode(statusCode: number): MethodDecorator;

package/decorators/http-code.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCode = void 0;
+const constants_1 = require("@venok/http/constants");
+/**
+ * Request method Decorator. Defines the HTTP response status code.  Overrides
+ * default status code for the decorated request method.
+ *
+ * @param statusCode HTTP response code to be returned by route handler.
+ *
+ * @publicApi
+ */
+function HttpCode(statusCode) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.HTTP_CODE_METADATA, statusCode, descriptor.value);
+        return descriptor;
+    };
+}
+exports.HttpCode = HttpCode;

package/decorators/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./controller.decorator";
+export * from "./header.decorator";
+export * from "./http-code.decorator";
+export * from "./redirect.decorator";
+export * from "./render.decorator";
+export * from "./request-mapping.decorator";
+export * from "./route-params.decorator";
+export * from "./sse.decorator";
+export * from "./version.decorator";

package/decorators/index.js

@@ -0,0 +1,25 @@
+"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("./controller.decorator"), exports);
+__exportStar(require("./header.decorator"), exports);
+__exportStar(require("./http-code.decorator"), exports);
+__exportStar(require("./redirect.decorator"), exports);
+__exportStar(require("./render.decorator"), exports);
+__exportStar(require("./request-mapping.decorator"), exports);
+__exportStar(require("./route-params.decorator"), exports);
+__exportStar(require("./sse.decorator"), exports);
+__exportStar(require("./version.decorator"), exports);

package/decorators/redirect.decorator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redirects request to the specified URL.
+ *
+ * @publicApi
+ */
+export declare function Redirect(url?: string, statusCode?: number): MethodDecorator;

package/decorators/redirect.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redirect = void 0;
+const constants_1 = require("@venok/http/constants");
+/**
+ * Redirects request to the specified URL.
+ *
+ * @publicApi
+ */
+function Redirect(url = "", statusCode) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.REDIRECT_METADATA, { statusCode, url }, descriptor.value);
+        return descriptor;
+    };
+}
+exports.Redirect = Redirect;

package/decorators/render.decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Route handler method Decorator. Defines a template to be rendered by the controller.
+ *
+ * For example: `@Render('index')`
+ *
+ * @param template name of the render engine template file
+ *
+ * @publicApi
+ */
+export declare function Render(template: string): MethodDecorator;

package/decorators/render.decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Render = void 0;
+const constants_1 = require("@venok/http/constants");
+/**
+ * Route handler method Decorator. Defines a template to be rendered by the controller.
+ *
+ * For example: `@Render('index')`
+ *
+ * @param template name of the render engine template file
+ *
+ * @publicApi
+ */
+function Render(template) {
+    return (target, key, descriptor) => {
+        Reflect.defineMetadata(constants_1.RENDER_METADATA, template, descriptor.value);
+        return descriptor;
+    };
+}
+exports.Render = Render;

package/decorators/request-mapping.decorator.d.ts

@@ -0,0 +1,78 @@
+import { RequestMethod } from "@venok/http/enums";
+export interface RequestMappingMetadata {
+    path?: string | string[];
+    method?: RequestMethod;
+}
+export declare const RequestMapping: (metadata?: RequestMappingMetadata) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP POST requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Post: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP GET requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Get: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP DELETE requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Delete: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP PUT requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Put: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP PATCH requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Patch: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP OPTIONS requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Options: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes HTTP HEAD requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Head: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes all HTTP requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const All: (path?: string | string[]) => MethodDecorator;
+/**
+ * Route handler (method) Decorator. Routes all HTTP requests to the specified path.
+ *
+ * @see [Routing](https://docs.nestjs.com/controllers#routing)
+ *
+ * @publicApi
+ */
+export declare const Search: (path?: string | string[]) => MethodDecorator;