@venok/core 1.0.0

package/decorators/catch.decorator.d.ts

@@ -0,0 +1,17 @@
+import { Abstract, Type } from "@venok/core/interfaces";
+/**
+ * Decorator that marks a class as a Venok exception filter. An exception filter
+ * handles exceptions thrown by or not handled by your application code.
+ *
+ * The decorated class must implement the `ExceptionFilter` interface.
+ *
+ * @param exceptions one or more exception *types* specifying
+ * the exceptions to be caught and handled by this filter.
+ *
+ * @usageNotes
+ * Exception filters are applied using the `@UseFilters()` decorator, or (globally)
+ * with `app.useGlobalFilters()`.
+ *
+ * @publicApi
+ */
+export declare function Catch(...exceptions: Array<Type<any> | Abstract<any>>): ClassDecorator;

package/decorators/catch.decorator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Catch = void 0;
+const constants_1 = require("@venok/core/constants");
+/**
+ * Decorator that marks a class as a Venok exception filter. An exception filter
+ * handles exceptions thrown by or not handled by your application code.
+ *
+ * The decorated class must implement the `ExceptionFilter` interface.
+ *
+ * @param exceptions one or more exception *types* specifying
+ * the exceptions to be caught and handled by this filter.
+ *
+ * @usageNotes
+ * Exception filters are applied using the `@UseFilters()` decorator, or (globally)
+ * with `app.useGlobalFilters()`.
+ *
+ * @publicApi
+ */
+function Catch(...exceptions) {
+    return (target) => {
+        Reflect.defineMetadata(constants_1.CATCH_WATERMARK, true, target);
+        Reflect.defineMetadata(constants_1.FILTER_CATCH_EXCEPTIONS, exceptions, target);
+    };
+}
+exports.Catch = Catch;

package/decorators/create-param.decorator.d.ts

@@ -0,0 +1,29 @@
+import { Type } from "@venok/core/interfaces";
+import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
+export type ParamDecoratorEnhancer = ParameterDecorator;
+/**
+ * @publicApi
+ */
+export type CustomParamFactory<TData = any, TInput = any, TOutput = any> = (data: TData, input: TInput) => TOutput;
+export type ParamData = object | string | number;
+export interface RouteParamMetadata {
+    index: number;
+    data?: ParamData;
+}
+export declare function assignMetadata<TParamtype = any, TArgs = any>(args: TArgs, paramtype: TParamtype, index: number, data?: ParamData, ...pipes: (Type<PipeTransform> | PipeTransform)[]): TArgs & {
+    [x: string]: {
+        index: number;
+        data: ParamData | undefined;
+        pipes: (PipeTransform<any, any> | Type<PipeTransform<any, any>>)[];
+    };
+};
+export declare function assignCustomParameterMetadata(args: Record<number, any>, paramtype: number | string, index: number, factory: CustomParamFactory, data?: ParamData, ...pipes: (Type<PipeTransform> | PipeTransform)[]): {};
+/**
+ * Defines HTTP route param decorator
+ *
+ * @param factory
+ *
+ * @param enhancers
+ * @publicApi
+ */
+export declare function createParamDecorator<FactoryData = any, FactoryInput = any, FactoryOutput = any>(factory: CustomParamFactory<FactoryData, FactoryInput, FactoryOutput>, enhancers?: ParamDecoratorEnhancer[]): (...dataOrPipes: (Type<PipeTransform> | PipeTransform | FactoryData)[]) => ParameterDecorator;

package/decorators/create-param.decorator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParamDecorator = exports.assignCustomParameterMetadata = exports.assignMetadata = void 0;
+const uid_1 = require("uid");
+const constants_1 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+function assignMetadata(args, paramtype, index, data, ...pipes) {
+    return {
+        ...args,
+        [`${paramtype}:${index}`]: {
+            index,
+            data,
+            pipes,
+        },
+    };
+}
+exports.assignMetadata = assignMetadata;
+function assignCustomParameterMetadata(args, paramtype, index, factory, data, ...pipes) {
+    return {
+        ...args,
+        [`${paramtype}${constants_1.CUSTOM_ROUTE_ARGS_METADATA}:${index}`]: {
+            index,
+            factory,
+            data,
+            pipes,
+        },
+    };
+}
+exports.assignCustomParameterMetadata = assignCustomParameterMetadata;
+/**
+ * Defines HTTP route param decorator
+ *
+ * @param factory
+ *
+ * @param enhancers
+ * @publicApi
+ */
+function createParamDecorator(factory, enhancers = []) {
+    const paramtype = (0, uid_1.uid)(21);
+    return (data, ...pipes) => (target, key, index) => {
+        const args = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, target.constructor, key) || {};
+        const isPipe = (pipe) => pipe &&
+            (((0, shared_helper_1.isFunction)(pipe) && pipe.prototype && (0, shared_helper_1.isFunction)(pipe.prototype.transform)) || (0, shared_helper_1.isFunction)(pipe.transform));
+        const hasParamData = (0, shared_helper_1.isNull)(data) || !isPipe(data);
+        const paramData = hasParamData ? data : undefined;
+        const paramPipes = hasParamData ? pipes : [data, ...pipes];
+        Reflect.defineMetadata(constants_1.ROUTE_ARGS_METADATA, assignCustomParameterMetadata(args, paramtype, index, factory, paramData, ...paramPipes), target.constructor, key);
+        enhancers.forEach((fn) => fn(target, key, index));
+    };
+}
+exports.createParamDecorator = createParamDecorator;

package/decorators/dependencies.decorator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Decorator that sets required dependencies (required with a vanilla JavaScript objects)
+ *
+ * @publicApi
+ */
+export declare const Dependencies: (...dependencies: Array<unknown>) => ClassDecorator;

package/decorators/dependencies.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependencies = void 0;
+const constants_1 = require("@venok/core/constants");
+const flatten_helper_1 = require("@venok/core/helpers/flatten.helper");
+/**
+ * Decorator that sets required dependencies (required with a vanilla JavaScript objects)
+ *
+ * @publicApi
+ */
+const Dependencies = (...dependencies) => {
+    const flattenDeps = (0, flatten_helper_1.flatten)(dependencies);
+    return (target) => {
+        Reflect.defineMetadata(constants_1.PARAMTYPES_METADATA, flattenDeps, target);
+    };
+};
+exports.Dependencies = Dependencies;

package/decorators/exception-filters.decorator.d.ts

@@ -0,0 +1,21 @@
+import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
+/**
+ * Decorator that binds exception filters to the scope of the controller or
+ * method, depending on its context.
+ *
+ * When `@UseFilters` is used at the provider level, the filter will be
+ * applied to every handler (method) in the provider.
+ *
+ * When `@UseFilters` is used at the individual handler level, the filter
+ * will apply only to that specific method.
+ *
+ * @param filters exception filter instance or class, or a list of exception
+ * filter instances or classes.
+ *
+ * @usageNotes
+ * Exception filters can also be set up globally for all controllers and routes
+ * using `app.useGlobalFilters()`.
+ *
+ * @publicApi
+ */
+export declare const UseFilters: (...filters: (ExceptionFilter | Function)[]) => MethodDecorator & ClassDecorator;

package/decorators/exception-filters.decorator.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseFilters = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const constants_1 = require("@venok/core/constants");
+const validate_each_helper_1 = require("@venok/core/helpers/validate-each.helper");
+const extends_metadata_helper_1 = require("@venok/core/helpers/extends-metadata.helper");
+/**
+ * Decorator that binds exception filters to the scope of the controller or
+ * method, depending on its context.
+ *
+ * When `@UseFilters` is used at the provider level, the filter will be
+ * applied to every handler (method) in the provider.
+ *
+ * When `@UseFilters` is used at the individual handler level, the filter
+ * will apply only to that specific method.
+ *
+ * @param filters exception filter instance or class, or a list of exception
+ * filter instances or classes.
+ *
+ * @usageNotes
+ * Exception filters can also be set up globally for all controllers and routes
+ * using `app.useGlobalFilters()`.
+ *
+ * @publicApi
+ */
+const UseFilters = (...filters) => addExceptionFiltersMetadata(...filters);
+exports.UseFilters = UseFilters;
+function addExceptionFiltersMetadata(...filters) {
+    return (target, key, descriptor) => {
+        const isFilterValid = (filter) => filter && ((0, shared_helper_1.isFunction)(filter) || (0, shared_helper_1.isFunction)(filter.catch));
+        if (descriptor) {
+            (0, validate_each_helper_1.validateEach)(target.constructor, filters, isFilterValid, "@UseFilters", "filter");
+            (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.EXCEPTION_FILTERS_METADATA, filters, descriptor.value);
+            return descriptor;
+        }
+        (0, validate_each_helper_1.validateEach)(target, filters, isFilterValid, "@UseFilters", "filter");
+        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.EXCEPTION_FILTERS_METADATA, filters, target);
+        return target;
+    };
+}

package/decorators/global.decorator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Decorator that makes a module global-scoped.
+ *
+ * Once imported into any module, a global-scoped module will be visible
+ * in all modules. Thereafter, modules that wish to inject a service exported
+ * from a global module do not need to import the provider module.
+ *
+ * @publicApi
+ */
+export declare function Global(): ClassDecorator;

package/decorators/global.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Global = void 0;
+const constants_1 = require("@venok/core/constants");
+/**
+ * Decorator that makes a module global-scoped.
+ *
+ * Once imported into any module, a global-scoped module will be visible
+ * in all modules. Thereafter, modules that wish to inject a service exported
+ * from a global module do not need to import the provider module.
+ *
+ * @publicApi
+ */
+function Global() {
+    return (target) => {
+        Reflect.defineMetadata(constants_1.GLOBAL_MODULE_METADATA, true, target);
+    };
+}
+exports.Global = Global;

package/decorators/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./apply.decorator";
+export * from "./bind.decorator";
+export * from "./catch.decorator";
+export * from "./create-param.decorator";
+export * from "./dependencies.decorator";
+export * from "./exception-filters.decorator";
+export * from "./global.decorator";
+export * from "./inject.decorator";
+export * from "./injectable.decorator";
+export * from "./module.decorator";
+export * from "./optional.decorator";
+export * from "./set-metadata.decorator";
+export * from "./use-guards.decorator";
+export * from "./use-pipes.decorator";
+export * from "./use-interceptors.decorator";

package/decorators/index.js

@@ -0,0 +1,31 @@
+"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("./apply.decorator"), exports);
+__exportStar(require("./bind.decorator"), exports);
+__exportStar(require("./catch.decorator"), exports);
+__exportStar(require("./create-param.decorator"), exports);
+__exportStar(require("./dependencies.decorator"), exports);
+__exportStar(require("./exception-filters.decorator"), exports);
+__exportStar(require("./global.decorator"), exports);
+__exportStar(require("./inject.decorator"), exports);
+__exportStar(require("./injectable.decorator"), exports);
+__exportStar(require("./module.decorator"), exports);
+__exportStar(require("./optional.decorator"), exports);
+__exportStar(require("./set-metadata.decorator"), exports);
+__exportStar(require("./use-guards.decorator"), exports);
+__exportStar(require("./use-pipes.decorator"), exports);
+__exportStar(require("./use-interceptors.decorator"), exports);

package/decorators/inject.decorator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Decorator that marks a constructor parameter as a target for
+ * Dependency Injection (DI).
+ *
+ * Any injected provider must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * #### Injection tokens
+ * Can be *types* (class names), *strings* or *symbols*. This depends on how the
+ * provider with which it is associated was defined. Providers defined with the
+ * `@Injectable()` decorator use the class name. Custom Providers may use strings
+ * or symbols as the injection token.
+ *
+ * @param token lookup key for the provider to be injected (assigned to the constructor
+ * parameter).
+ *
+ * @publicApi
+ */
+export declare function Inject<T = any>(token?: T): PropertyDecorator & ParameterDecorator;

package/decorators/inject.decorator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const constants_1 = require("@venok/core/constants");
+/**
+ * Decorator that marks a constructor parameter as a target for
+ * Dependency Injection (DI).
+ *
+ * Any injected provider must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * #### Injection tokens
+ * Can be *types* (class names), *strings* or *symbols*. This depends on how the
+ * provider with which it is associated was defined. Providers defined with the
+ * `@Injectable()` decorator use the class name. Custom Providers may use strings
+ * or symbols as the injection token.
+ *
+ * @param token lookup key for the provider to be injected (assigned to the constructor
+ * parameter).
+ *
+ * @publicApi
+ */
+function Inject(token) {
+    return (target, key, index) => {
+        const type = token || Reflect.getMetadata("design:type", target, key);
+        if (!(0, shared_helper_1.isUndefined)(index)) {
+            let dependencies = Reflect.getMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, target) || [];
+            dependencies = [...dependencies, { index, param: type }];
+            Reflect.defineMetadata(constants_1.SELF_DECLARED_DEPS_METADATA, dependencies, target);
+            return;
+        }
+        let properties = Reflect.getMetadata(constants_1.PROPERTY_DEPS_METADATA, target.constructor) || [];
+        properties = [...properties, { key, type }];
+        Reflect.defineMetadata(constants_1.PROPERTY_DEPS_METADATA, properties, target.constructor);
+    };
+}
+exports.Inject = Inject;

package/decorators/injectable.decorator.d.ts

@@ -0,0 +1,40 @@
+import { ScopeOptions, Type } from "@venok/core/interfaces";
+/**
+ * Defines the injection scope.
+ *
+ * @publicApi
+ */
+export type InjectableOptions = ScopeOptions;
+/**
+ * Decorator that marks a class as a provider(https://venok.com/providers).
+ * Providers can be injected into other classes via constructor parameter injection
+ * using Venok built-in [Dependency Injection (DI)](https://venok.com/providers#dependency-injection)
+ * system.
+ *
+ * When injecting a provider, it must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * Providers can also be defined in a more explicit and imperative form using
+ * various [custom provider](https://venok.com/fundamentals/custom-providers) techniques that expose
+ * more capabilities of the DI system.
+ *
+ * @param options options specifying scope of injectable
+ *
+ * @see [Providers](https://venok.com/providers)
+ * @see [Custom Providers](https://venok.com/fundamentals/custom-providers)
+ * @see [Injection Scopes](https://venok.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+export declare function Injectable(options?: InjectableOptions): ClassDecorator;
+/**
+ * @publicApi
+ */
+export declare function mixin<T>(mixinClass: Type<T>): Type<T>;

package/decorators/injectable.decorator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mixin = exports.Injectable = void 0;
+const uid_1 = require("uid");
+const constants_1 = require("@venok/core/constants");
+/**
+ * Decorator that marks a class as a provider(https://venok.com/providers).
+ * Providers can be injected into other classes via constructor parameter injection
+ * using Venok built-in [Dependency Injection (DI)](https://venok.com/providers#dependency-injection)
+ * system.
+ *
+ * When injecting a provider, it must be visible within the module scope (loosely
+ * speaking, the containing module) of the class it is being injected into. This
+ * can be done by:
+ *
+ * - defining the provider in the same module scope
+ * - exporting the provider from one module scope and importing that module into the
+ *   module scope of the class being injected into
+ * - exporting the provider from a module that is marked as global using the
+ *   `@Global()` decorator
+ *
+ * Providers can also be defined in a more explicit and imperative form using
+ * various [custom provider](https://venok.com/fundamentals/custom-providers) techniques that expose
+ * more capabilities of the DI system.
+ *
+ * @param options options specifying scope of injectable
+ *
+ * @see [Providers](https://venok.com/providers)
+ * @see [Custom Providers](https://venok.com/fundamentals/custom-providers)
+ * @see [Injection Scopes](https://venok.com/fundamentals/injection-scopes)
+ *
+ * @publicApi
+ */
+function Injectable(options) {
+    return (target) => {
+        Reflect.defineMetadata(constants_1.INJECTABLE_WATERMARK, true, target);
+        Reflect.defineMetadata(constants_1.SCOPE_OPTIONS_METADATA, options, target);
+    };
+}
+exports.Injectable = Injectable;
+/**
+ * @publicApi
+ */
+function mixin(mixinClass) {
+    Object.defineProperty(mixinClass, "name", {
+        value: (0, uid_1.uid)(21),
+    });
+    Injectable()(mixinClass);
+    return mixinClass;
+}
+exports.mixin = mixin;

package/decorators/module.decorator.d.ts

@@ -0,0 +1,14 @@
+import { ModuleMetadata } from "@venok/core/interfaces/modules";
+export declare const INVALID_MODULE_CONFIG_MESSAGE: (text: TemplateStringsArray, property: string) => string;
+/**
+ * Decorator that marks a class as a module.
+ *
+ * Modules are used by Venok to organize the application structure into scopes.
+ * Providers are scoped by the module they are declared in. Modules and their
+ * classes (Providers) form a graph that determines how Venok
+ *
+ * @param metadata module configuration metadata
+ *
+ * @publicApi
+ */
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;

package/decorators/module.decorator.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = exports.INVALID_MODULE_CONFIG_MESSAGE = void 0;
+const constants_1 = require("../constants");
+const INVALID_MODULE_CONFIG_MESSAGE = (text, property) => `Invalid property '${property}' passed into the @Module() decorator.`;
+exports.INVALID_MODULE_CONFIG_MESSAGE = INVALID_MODULE_CONFIG_MESSAGE;
+const metadataKeys = [constants_1.MODULE_METADATA.IMPORTS, constants_1.MODULE_METADATA.EXPORTS, constants_1.MODULE_METADATA.PROVIDERS];
+function validateModuleKeys(keys) {
+    const validateKey = (key) => {
+        if (metadataKeys.includes(key))
+            return;
+        throw new Error((0, exports.INVALID_MODULE_CONFIG_MESSAGE) `${key}`);
+    };
+    keys.forEach(validateKey);
+}
+/**
+ * Decorator that marks a class as a module.
+ *
+ * Modules are used by Venok to organize the application structure into scopes.
+ * Providers are scoped by the module they are declared in. Modules and their
+ * classes (Providers) form a graph that determines how Venok
+ *
+ * @param metadata module configuration metadata
+ *
+ * @publicApi
+ */
+function Module(metadata) {
+    const propsKeys = Object.keys(metadata);
+    validateModuleKeys(propsKeys);
+    return (target) => {
+        for (const property in metadata) {
+            if (metadata.hasOwnProperty(property)) {
+                Reflect.defineMetadata(property, metadata[property], target);
+            }
+        }
+    };
+}
+exports.Module = Module;

package/decorators/optional.decorator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parameter decorator for an injected dependency marking the
+ * dependency as optional.
+ *
+ * For example:
+ * ```typescript
+ * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
+ * ```
+ *
+ * @see [Optional providers](https://venok.com/providers#optional-providers)
+ *
+ * @publicApi
+ */
+export declare function Optional(): PropertyDecorator & ParameterDecorator;

package/decorators/optional.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = void 0;
+const constants_1 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+/**
+ * Parameter decorator for an injected dependency marking the
+ * dependency as optional.
+ *
+ * For example:
+ * ```typescript
+ * constructor(@Optional() @Inject('HTTP_OPTIONS')private readonly httpClient: T) {}
+ * ```
+ *
+ * @see [Optional providers](https://venok.com/providers#optional-providers)
+ *
+ * @publicApi
+ */
+function Optional() {
+    return (target, key, index) => {
+        if (!(0, shared_helper_1.isUndefined)(index)) {
+            const args = Reflect.getMetadata(constants_1.OPTIONAL_DEPS_METADATA, target) || [];
+            Reflect.defineMetadata(constants_1.OPTIONAL_DEPS_METADATA, [...args, index], target);
+            return;
+        }
+        const properties = Reflect.getMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, target.constructor) || [];
+        Reflect.defineMetadata(constants_1.OPTIONAL_PROPERTY_DEPS_METADATA, [...properties, key], target.constructor);
+    };
+}
+exports.Optional = Optional;

package/decorators/set-metadata.decorator.d.ts

@@ -0,0 +1,18 @@
+export type CustomDecorator<TKey = string> = MethodDecorator & ClassDecorator & {
+    KEY: TKey;
+};
+/**
+ * Decorator that assigns metadata to the class/function using the
+ * specified `key`.
+ *
+ * Requires two parameters:
+ * - `key` - a value defining the key under which the metadata is stored
+ * - `value` - metadata to be associated with `key`
+ *
+ * This metadata can be reflected using the `Reflector` class.
+ *
+ * Example: `@SetMetadata('roles', ['admin'])`
+ *
+ * @publicApi
+ */
+export declare const SetMetadata: <K = string, V = any>(metadataKey: K, metadataValue: V) => CustomDecorator<K>;

package/decorators/set-metadata.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetMetadata = void 0;
+/**
+ * Decorator that assigns metadata to the class/function using the
+ * specified `key`.
+ *
+ * Requires two parameters:
+ * - `key` - a value defining the key under which the metadata is stored
+ * - `value` - metadata to be associated with `key`
+ *
+ * This metadata can be reflected using the `Reflector` class.
+ *
+ * Example: `@SetMetadata('roles', ['admin'])`
+ *
+ * @publicApi
+ */
+const SetMetadata = (metadataKey, metadataValue) => {
+    const decoratorFactory = (target, key, descriptor) => {
+        if (descriptor) {
+            Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+            return descriptor;
+        }
+        Reflect.defineMetadata(metadataKey, metadataValue, target);
+        return target;
+    };
+    decoratorFactory.KEY = metadataKey;
+    return decoratorFactory;
+};
+exports.SetMetadata = SetMetadata;

package/decorators/use-guards.decorator.d.ts

@@ -0,0 +1,21 @@
+import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
+/**
+ * Decorator that binds guards to the scope of the provider or method,
+ * depending on its context.
+ *
+ * When `@UseGuards` is used at the controller level, the guard will be
+ * applied to every handler (method) in the provider.
+ *
+ * When `@UseGuards` is used at the individual handler level, the guard
+ * will apply only to that specific method.
+ *
+ * @param guards a single guard instance or class, or a list of guard instances
+ * or classes.
+ *
+ * @usageNotes
+ * Guards can also be set up globally for all controllers and routes
+ * using `app.useGlobalGuards()`.
+ *
+ * @publicApi
+ */
+export declare function UseGuards(...guards: (CanActivate | Function)[]): MethodDecorator & ClassDecorator;