@venok/core 1.0.0

package/decorators/use-guards.decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseGuards = 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 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
+ */
+function UseGuards(...guards) {
+    return (target, key, descriptor) => {
+        const isGuardValid = (guard) => guard && ((0, shared_helper_1.isFunction)(guard) || (0, shared_helper_1.isFunction)(guard.canActivate));
+        if (descriptor) {
+            (0, validate_each_helper_1.validateEach)(target.constructor, guards, isGuardValid, "@UseGuards", "guard");
+            (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.GUARDS_METADATA, guards, descriptor.value);
+            return descriptor;
+        }
+        (0, validate_each_helper_1.validateEach)(target, guards, isGuardValid, "@UseGuards", "guard");
+        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.GUARDS_METADATA, guards, target);
+        return target;
+    };
+}
+exports.UseGuards = UseGuards;

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

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

package/decorators/use-interceptors.decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseInterceptors = 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 interceptors to the scope of the provider or method,
+ * depending on its context.
+ *
+ * When `@UseInterceptors` is used at the controller level, the interceptor will
+ * be applied to every handler (method) in the provider.
+ *
+ * When `@UseInterceptors` is used at the individual handler level, the interceptor
+ * will apply only to that specific method.
+ *
+ * @param interceptors a single interceptor instance or class, or a list of
+ * interceptor instances or classes.
+ *
+ * @usageNotes
+ * Interceptors can also be set up globally for all controllers and routes
+ * using `app.useGlobalInterceptors()`.
+ *
+ * @publicApi
+ */
+function UseInterceptors(...interceptors) {
+    return (target, key, descriptor) => {
+        const isInterceptorValid = (interceptor) => interceptor && ((0, shared_helper_1.isFunction)(interceptor) || (0, shared_helper_1.isFunction)(interceptor.intercept));
+        if (descriptor) {
+            (0, validate_each_helper_1.validateEach)(target.constructor, interceptors, isInterceptorValid, "@UseInterceptors", "interceptor");
+            (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.INTERCEPTORS_METADATA, interceptors, descriptor.value);
+            return descriptor;
+        }
+        (0, validate_each_helper_1.validateEach)(target, interceptors, isInterceptorValid, "@UseInterceptors", "interceptor");
+        (0, extends_metadata_helper_1.extendArrayMetadata)(constants_1.INTERCEPTORS_METADATA, interceptors, target);
+        return target;
+    };
+}
+exports.UseInterceptors = UseInterceptors;

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

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

package/decorators/use-pipes.decorator.js

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

package/discovery/meta-host-collection.d.ts

@@ -0,0 +1,32 @@
+import { Type } from "@venok/core/interfaces";
+import { ModulesContainer } from "@venok/core/injector/module/container";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+export declare class DiscoverableMetaHostCollection {
+    /**
+     * A map of class references to metadata keys.
+     */
+    static readonly metaHostLinks: Map<Function | Type<any>, string>;
+    /**
+     * A map of metadata keys to instance wrappers (providers) with the corresponding metadata key.
+     * The map is weakly referenced by the modules container (unique per application).
+     */
+    private static readonly providersByMetaKey;
+    /**
+     * Adds a link between a class reference and a metadata key.
+     * @param target The class reference.
+     * @param metadataKey The metadata key.
+     */
+    static addClassMetaHostLink(target: Type | Function, metadataKey: string): void;
+    /**
+     * Inspects a provider instance wrapper and adds it to the collection of providers
+     * if it has a metadata key.
+     * @param hostContainerRef A reference to the module's container.
+     * @param instanceWrapper A provider instance wrapper.
+     * @returns void
+     */
+    static inspectProvider(hostContainerRef: ModulesContainer, instanceWrapper: InstanceWrapper): void;
+    static insertByMetaKey(metaKey: string, instanceWrapper: InstanceWrapper, collection: Map<string, Set<InstanceWrapper>>): void;
+    static getProvidersByMetaKey(hostContainerRef: ModulesContainer, metaKey: string): Set<InstanceWrapper>;
+    private static inspectInstanceWrapper;
+    private static getMetaKeyByInstanceWrapper;
+}

package/discovery/meta-host-collection.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverableMetaHostCollection = void 0;
+class DiscoverableMetaHostCollection {
+    /**
+     * Adds a link between a class reference and a metadata key.
+     * @param target The class reference.
+     * @param metadataKey The metadata key.
+     */
+    static addClassMetaHostLink(target, metadataKey) {
+        this.metaHostLinks.set(target, metadataKey);
+    }
+    /**
+     * Inspects a provider instance wrapper and adds it to the collection of providers
+     * if it has a metadata key.
+     * @param hostContainerRef A reference to the module's container.
+     * @param instanceWrapper A provider instance wrapper.
+     * @returns void
+     */
+    static inspectProvider(hostContainerRef, instanceWrapper) {
+        return this.inspectInstanceWrapper(hostContainerRef, instanceWrapper, this.providersByMetaKey);
+    }
+    static insertByMetaKey(metaKey, instanceWrapper, collection) {
+        if (collection.has(metaKey)) {
+            const wrappers = collection.get(metaKey);
+            wrappers.add(instanceWrapper);
+        }
+        else {
+            const wrappers = new Set();
+            wrappers.add(instanceWrapper);
+            collection.set(metaKey, wrappers);
+        }
+    }
+    static getProvidersByMetaKey(hostContainerRef, metaKey) {
+        const wrappersByMetaKey = this.providersByMetaKey.get(hostContainerRef);
+        return wrappersByMetaKey.get(metaKey);
+    }
+    static inspectInstanceWrapper(hostContainerRef, instanceWrapper, wrapperByMetaKeyMap) {
+        const metaKey = DiscoverableMetaHostCollection.getMetaKeyByInstanceWrapper(instanceWrapper);
+        if (!metaKey) {
+            return;
+        }
+        let collection;
+        if (wrapperByMetaKeyMap.has(hostContainerRef)) {
+            collection = wrapperByMetaKeyMap.get(hostContainerRef);
+        }
+        else {
+            collection = new Map();
+            wrapperByMetaKeyMap.set(hostContainerRef, collection);
+        }
+        this.insertByMetaKey(metaKey, instanceWrapper, collection);
+    }
+    static getMetaKeyByInstanceWrapper(instanceWrapper) {
+        return this.metaHostLinks.get(
+        // NOTE: Regarding the ternary statement below,
+        // - The condition `!wrapper.metatype` is needed because when we use `useValue`
+        // the value of `wrapper.metatype` will be `null`.
+        // - The condition `wrapper.inject` is needed here because when we use
+        // `useFactory`, the value of `wrapper.metatype` will be the supplied
+        // factory function.
+        // For both cases, we should use `wrapper.instance.constructor` instead
+        // of `wrapper.metatype` to resolve processor's class properly.
+        // But since calling `wrapper.instance` could degrade overall performance
+        // we must defer it as much we can.
+        instanceWrapper.metatype || instanceWrapper.inject
+            ? instanceWrapper.instance?.constructor ?? instanceWrapper.metatype
+            : instanceWrapper.metatype);
+    }
+}
+exports.DiscoverableMetaHostCollection = DiscoverableMetaHostCollection;
+/**
+ * A map of class references to metadata keys.
+ */
+DiscoverableMetaHostCollection.metaHostLinks = new Map();
+/**
+ * A map of metadata keys to instance wrappers (providers) with the corresponding metadata key.
+ * The map is weakly referenced by the modules container (unique per application).
+ */
+DiscoverableMetaHostCollection.providersByMetaKey = new WeakMap();

package/discovery/module.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @publicApi
+ */
+export declare class DiscoveryModule {
+}

package/discovery/module.js

@@ -0,0 +1,24 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryModule = void 0;
+const metadata_scanner_1 = require("@venok/core/metadata-scanner");
+const module_decorator_1 = require("@venok/core/decorators/module.decorator");
+const service_1 = require("@venok/core/discovery/service");
+/**
+ * @publicApi
+ */
+let DiscoveryModule = class DiscoveryModule {
+};
+exports.DiscoveryModule = DiscoveryModule;
+exports.DiscoveryModule = DiscoveryModule = __decorate([
+    (0, module_decorator_1.Module)({
+        providers: [metadata_scanner_1.MetadataScanner, service_1.DiscoveryService],
+        exports: [metadata_scanner_1.MetadataScanner, service_1.DiscoveryService],
+    })
+], DiscoveryModule);

package/discovery/service.d.ts

@@ -0,0 +1,68 @@
+import { ModulesContainer } from "@venok/core/injector/module/container";
+import { CustomDecorator } from "@venok/core/decorators/set-metadata.decorator";
+import { Module } from "@venok/core/injector/module/module";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+/**
+ * @publicApi
+ */
+export interface FilterByInclude {
+    /**
+     * List of modules to include (whitelist) into the discovery process.
+     */
+    include?: Function[];
+}
+/**
+ * @publicApi
+ */
+export interface FilterByMetadataKey {
+    /**
+     * A key to filter controllers and providers by.
+     * Only instance wrappers with the specified metadata key will be returned.
+     */
+    metadataKey?: string;
+}
+/**
+ * @publicApi
+ */
+export type DiscoveryOptions = FilterByInclude | FilterByMetadataKey;
+/**
+ * @publicApi
+ */
+export type DiscoverableDecorator<T> = ((opts?: T) => CustomDecorator) & {
+    KEY: string;
+};
+/**
+ * @publicApi
+ */
+export declare class DiscoveryService {
+    private readonly modulesContainer;
+    constructor(modulesContainer: ModulesContainer);
+    /**
+     * Creates a decorator that can be used to decorate classes and methods with metadata.
+     * The decorator will also add the class to the collection of discoverable classes (by metadata key).
+     * Decorated classes can be discovered using the `getProviders` and `getControllers` methods.
+     * @returns A decorator function.
+     */
+    static createDecorator<T>(): DiscoverableDecorator<T>;
+    /**
+     * Returns an array of instance wrappers (providers).
+     * Depending on the options, the array will contain either all providers or only providers with the specified metadata key.
+     * @param options Discovery options.
+     * @param modules A list of modules to filter by.
+     * @returns An array of instance wrappers (providers).
+     */
+    getProviders(options?: DiscoveryOptions, modules?: Module[]): InstanceWrapper[];
+    /**
+     * Retrieves metadata from the specified instance wrapper.
+     * @param decorator The decorator to retrieve metadata of.
+     * @param instanceWrapper Reference to the instance wrapper.
+     * @param methodKey An optional method key to retrieve metadata from.
+     * @returns Discovered metadata.
+     */
+    getMetadataByDecorator<T extends DiscoverableDecorator<any>>(decorator: T, instanceWrapper: InstanceWrapper, methodKey?: string): T extends DiscoverableDecorator<infer R> ? R | undefined : T | undefined;
+    /**
+     * Returns a list of modules to be used for discovery.
+     */
+    protected getModules(options?: DiscoveryOptions): Module[];
+    private includeWhitelisted;
+}

package/discovery/service.js

@@ -0,0 +1,90 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryService = void 0;
+const container_1 = require("@venok/core/injector/module/container");
+const set_metadata_decorator_1 = require("@venok/core/decorators/set-metadata.decorator");
+const injectable_decorator_1 = require("@venok/core/decorators/injectable.decorator");
+const uid_1 = require("uid");
+const meta_host_collection_1 = require("@venok/core/discovery/meta-host-collection");
+const flatten_helper_1 = require("@venok/core/helpers/flatten.helper");
+/**
+ * @publicApi
+ */
+let DiscoveryService = class DiscoveryService {
+    constructor(modulesContainer) {
+        this.modulesContainer = modulesContainer;
+    }
+    /**
+     * Creates a decorator that can be used to decorate classes and methods with metadata.
+     * The decorator will also add the class to the collection of discoverable classes (by metadata key).
+     * Decorated classes can be discovered using the `getProviders` and `getControllers` methods.
+     * @returns A decorator function.
+     */
+    static createDecorator() {
+        const metadataKey = (0, uid_1.uid)(21);
+        const decoratorFn = (opts) => (target, key, descriptor) => {
+            if (!descriptor) {
+                meta_host_collection_1.DiscoverableMetaHostCollection.addClassMetaHostLink(target, metadataKey);
+            }
+            (0, set_metadata_decorator_1.SetMetadata)(metadataKey, opts ?? {})(target, key ?? "", descriptor);
+        };
+        decoratorFn.KEY = metadataKey;
+        return decoratorFn;
+    }
+    /**
+     * Returns an array of instance wrappers (providers).
+     * Depending on the options, the array will contain either all providers or only providers with the specified metadata key.
+     * @param options Discovery options.
+     * @param modules A list of modules to filter by.
+     * @returns An array of instance wrappers (providers).
+     */
+    getProviders(options = {}, modules = this.getModules(options)) {
+        if ("metadataKey" in options && options.metadataKey) {
+            const providers = meta_host_collection_1.DiscoverableMetaHostCollection.getProvidersByMetaKey(this.modulesContainer, options.metadataKey);
+            return Array.from(providers);
+        }
+        const providers = modules.map((item) => [...item.providers.values()]);
+        return (0, flatten_helper_1.flatten)(providers);
+    }
+    /**
+     * Retrieves metadata from the specified instance wrapper.
+     * @param decorator The decorator to retrieve metadata of.
+     * @param instanceWrapper Reference to the instance wrapper.
+     * @param methodKey An optional method key to retrieve metadata from.
+     * @returns Discovered metadata.
+     */
+    getMetadataByDecorator(decorator, instanceWrapper, methodKey) {
+        if (methodKey) {
+            return Reflect.getMetadata(decorator.KEY, instanceWrapper.instance[methodKey]);
+        }
+        const clsRef = instanceWrapper.instance?.constructor ?? instanceWrapper.metatype;
+        return Reflect.getMetadata(decorator.KEY, clsRef);
+    }
+    /**
+     * Returns a list of modules to be used for discovery.
+     */
+    getModules(options = {}) {
+        if (!("include" in options && options.include)) {
+            return [...this.modulesContainer.values()];
+        }
+        return this.includeWhitelisted(options.include);
+    }
+    includeWhitelisted(include) {
+        const moduleRefs = [...this.modulesContainer.values()];
+        return moduleRefs.filter(({ metatype }) => include.some((item) => item === metatype));
+    }
+};
+exports.DiscoveryService = DiscoveryService;
+exports.DiscoveryService = DiscoveryService = __decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    __metadata("design:paramtypes", [container_1.ModulesContainer])
+], DiscoveryService);

package/errors/exceptions/circular-dependency.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class CircularDependencyException extends RuntimeException {
+    constructor(context?: string);
+}

package/errors/exceptions/circular-dependency.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularDependencyException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class CircularDependencyException extends runtime_exception_1.RuntimeException {
+    constructor(context) {
+        const ctx = context ? ` inside ${context}` : ``;
+        super(`A circular dependency has been detected${ctx}. Please, make sure that each side of a bidirectional relationships are decorated with "forwardRef()". Note that circular relationships between custom providers (e.g., factories) are not supported since functions cannot be called more than once.`);
+    }
+}
+exports.CircularDependencyException = CircularDependencyException;

package/errors/exceptions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './circular-dependency.exception';
+export * from './runtime.exception';
+export * from './unknown-element.exception';
+export * from './invalid-class-scope.exception';
+export * from './invalid-class.exception';
+export * from './unknown-export.exception';
+export * from './unknown-module.exception';
+export * from './undefined-forwardref.exception';

package/errors/exceptions/index.js

@@ -0,0 +1,24 @@
+"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("./circular-dependency.exception"), exports);
+__exportStar(require("./runtime.exception"), exports);
+__exportStar(require("./unknown-element.exception"), exports);
+__exportStar(require("./invalid-class-scope.exception"), exports);
+__exportStar(require("./invalid-class.exception"), exports);
+__exportStar(require("./unknown-export.exception"), exports);
+__exportStar(require("./unknown-module.exception"), exports);
+__exportStar(require("./undefined-forwardref.exception"), exports);

package/errors/exceptions/invalid-class-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class InvalidClassModuleException extends RuntimeException {
+    constructor(metatypeUsedAsAModule: any, scope: any[]);
+}

package/errors/exceptions/invalid-class-module.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassModuleException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassModuleException extends runtime_exception_1.RuntimeException {
+    constructor(metatypeUsedAsAModule, scope) {
+        super((0, messages_1.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE)(metatypeUsedAsAModule, scope));
+    }
+}
+exports.InvalidClassModuleException = InvalidClassModuleException;

package/errors/exceptions/invalid-class-scope.exception.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeException } from "./runtime.exception";
+import { Abstract, Type } from "@venok/core/interfaces";
+export declare class InvalidClassScopeException extends RuntimeException {
+    constructor(metatypeOrToken: Type<any> | Abstract<any> | string | symbol);
+}

package/errors/exceptions/invalid-class-scope.exception.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassScopeException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+class InvalidClassScopeException extends runtime_exception_1.RuntimeException {
+    constructor(metatypeOrToken) {
+        let name = (0, shared_helper_1.isFunction)(metatypeOrToken) ? metatypeOrToken.name : metatypeOrToken;
+        name = name && name.toString();
+        super((0, messages_1.INVALID_CLASS_SCOPE_MESSAGE) `${name}`);
+    }
+}
+exports.InvalidClassScopeException = InvalidClassScopeException;

package/errors/exceptions/invalid-class.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class InvalidClassException extends RuntimeException {
+    constructor(value: any);
+}

package/errors/exceptions/invalid-class.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassException extends runtime_exception_1.RuntimeException {
+    constructor(value) {
+        super((0, messages_1.INVALID_CLASS_MESSAGE) `${value}`);
+    }
+}
+exports.InvalidClassException = InvalidClassException;

package/errors/exceptions/invalid-exception-filter.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class InvalidExceptionFilterException extends RuntimeException {
+    constructor();
+}

package/errors/exceptions/invalid-exception-filter.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidExceptionFilterException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class InvalidExceptionFilterException extends runtime_exception_1.RuntimeException {
+    constructor() {
+        super(messages_1.INVALID_EXCEPTION_FILTER);
+    }
+}
+exports.InvalidExceptionFilterException = InvalidExceptionFilterException;

package/errors/exceptions/invalid-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from "./runtime.exception";
+export declare class InvalidModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}

package/errors/exceptions/invalid-module.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidModuleException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidModuleException extends runtime_exception_1.RuntimeException {
+    constructor(parentModule, index, scope) {
+        super((0, messages_1.INVALID_MODULE_MESSAGE)(parentModule, index, scope));
+    }
+}
+exports.InvalidModuleException = InvalidModuleException;

package/errors/exceptions/runtime.exception.d.ts

@@ -0,0 +1,4 @@
+export declare class RuntimeException extends Error {
+    constructor(message?: string);
+    what(): string;
+}

package/errors/exceptions/runtime.exception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeException = void 0;
+class RuntimeException extends Error {
+    constructor(message = ``) {
+        super(message);
+    }
+    what() {
+        return this.message;
+    }
+}
+exports.RuntimeException = RuntimeException;

package/errors/exceptions/undefined-dependency.exception.d.ts

@@ -0,0 +1,6 @@
+import { InjectorDependencyContext } from "../../injector/injector";
+import { RuntimeException } from "./runtime.exception";
+import { Module } from "../../injector/module/module";
+export declare class UndefinedDependencyException extends RuntimeException {
+    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, module: Module);
+}