@venok/core 1.0.0

package/guards/context-creator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardsContextCreator = void 0;
+const creator_1 = require("@venok/core/context/creator");
+const constants_1 = require("@venok/core/injector/constants");
+const constants_2 = require("@venok/core/constants");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+class GuardsContextCreator extends creator_1.ContextCreator {
+    constructor(container, config) {
+        super();
+        this.container = container;
+        this.config = config;
+    }
+    create(instance, callback, module, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = module;
+        return this.createContext(instance, callback, constants_2.GUARDS_METADATA, contextId, inquirerId);
+    }
+    createConcreteContext(metadata, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_helper_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return metadata
+            .filter((guard) => guard && (guard.name || guard.canActivate))
+            .map((guard) => this.getGuardInstance(guard, contextId, inquirerId))
+            .filter((guard) => guard && (0, shared_helper_1.isFunction)(guard.canActivate));
+    }
+    getGuardInstance(metatype, contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        const isObject = metatype.canActivate;
+        // Maybe error
+        // @ts-ignore
+        if (isObject) {
+            return metatype;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(metatype);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        const injectables = moduleRef.injectables;
+        return injectables.get(metatype);
+    }
+    getGlobalMetadata(contextId = constants_1.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalGuards = this.config.getGlobalGuards();
+        if (contextId === constants_1.STATIC_CONTEXT && !inquirerId) {
+            return globalGuards;
+        }
+        const scopedGuardWrappers = this.config.getGlobalRequestGuards();
+        const scopedGuards = scopedGuardWrappers
+            .map((wrapper) => wrapper.getInstanceByContextId(this.getContextId(contextId, wrapper), inquirerId))
+            .filter((host) => !!host)
+            .map((host) => host.instance);
+        return globalGuards.concat(scopedGuards);
+    }
+}
+exports.GuardsContextCreator = GuardsContextCreator;

package/guards/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./consumer";
+export * from "./context-creator";

package/guards/index.js

@@ -0,0 +1,18 @@
+"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("./consumer"), exports);
+__exportStar(require("./context-creator"), exports);

package/helpers/color.helper.d.ts

@@ -0,0 +1,9 @@
+export declare const colors: {
+    bold: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    red: (text: string) => string;
+    magentaBright: (text: string) => string;
+    cyanBright: (text: string) => string;
+};
+export declare const yellow: (text: string) => string;

package/helpers/color.helper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yellow = exports.colors = void 0;
+const isColorAllowed = () => !process.env.NO_COLOR;
+const colorIfAllowed = (colorFn) => (text) => (isColorAllowed() ? colorFn(text) : text);
+exports.colors = {
+    bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+    green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+    yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+    red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+    magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+    cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`),
+};
+exports.yellow = colorIfAllowed((text) => `\x1B[38;5;3m${text}\x1B[39m`);

package/helpers/context-id-factory.helper.d.ts

@@ -0,0 +1,2 @@
+import { ContextId } from "@venok/core/injector/instance/wrapper";
+export declare function createContextId(): ContextId;

package/helpers/context-id-factory.helper.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextId = void 0;
+function createContextId() {
+    /**
+     * We are generating random identifier to track asynchronous
+     * execution context. An identifier does not have to be neither unique
+     * nor unpredictable because WeakMap uses objects as keys (reference comparison).
+     * Thus, even though identifier number might be equal, WeakMap would properly
+     * associate asynchronous context with its internal map values using object reference.
+     * Object is automatically removed once request has been processed (closure).
+     */
+    return { id: Math.random() };
+}
+exports.createContextId = createContextId;

package/helpers/context.helper.d.ts

@@ -0,0 +1,23 @@
+import { ParamData } from "@venok/core/decorators/create-param.decorator";
+import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
+import { ExecutionContextHost } from "@venok/core/context/execution-host";
+import { ContextType } from "@venok/core/interfaces/context/arguments-host.interface";
+export interface ParamProperties<T = any, IExtractor extends Function = any> {
+    index: number;
+    type: T | string;
+    data: ParamData;
+    pipes: PipeTransform[];
+    extractValue: IExtractor;
+}
+export declare class ContextUtils {
+    mapParamType(key: string): string;
+    reflectCallbackParamtypes(instance: object, methodName: string): any[];
+    reflectCallbackMetadata<T = any>(instance: object, methodName: string, metadataKey: string): T;
+    getArgumentsLength<T>(keys: string[], metadata: T): number;
+    createNullArray(length: number): any[];
+    mergeParamsMetatypes(paramsProperties: ParamProperties[], paramtypes: any[]): (ParamProperties & {
+        metatype?: any;
+    })[];
+    getCustomFactory(factory: (...args: unknown[]) => void, data: unknown, contextFactory: (args: unknown[]) => ExecutionContextHost): (...args: unknown[]) => unknown;
+    getContextFactory<TContext extends string = ContextType>(contextType: TContext, instance?: object, callback?: Function): (args: unknown[]) => ExecutionContextHost;
+}

package/helpers/context.helper.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextUtils = void 0;
+const constants_1 = require("@venok/core/constants");
+const execution_host_1 = require("@venok/core/context/execution-host");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+class ContextUtils {
+    mapParamType(key) {
+        const keyPair = key.split(":");
+        return keyPair[0];
+    }
+    reflectCallbackParamtypes(instance, methodName) {
+        return Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, instance, methodName);
+    }
+    reflectCallbackMetadata(instance, methodName, metadataKey) {
+        return Reflect.getMetadata(metadataKey, instance.constructor, methodName);
+    }
+    getArgumentsLength(keys, metadata) {
+        // Maybe Error
+        // @ts-ignore
+        return keys.length ? Math.max(...keys.map((key) => metadata[key].index)) + 1 : 0;
+    }
+    createNullArray(length) {
+        const a = new Array(length);
+        for (let i = 0; i < length; ++i)
+            a[i] = undefined;
+        return a;
+    }
+    mergeParamsMetatypes(paramsProperties, paramtypes) {
+        if (!paramtypes) {
+            return paramsProperties;
+        }
+        return paramsProperties.map((param) => ({
+            ...param,
+            metatype: paramtypes[param.index],
+        }));
+    }
+    getCustomFactory(factory, data, contextFactory) {
+        return (0, shared_helper_1.isFunction)(factory) ? (...args) => factory(data, contextFactory(args)) : () => null;
+    }
+    getContextFactory(contextType, instance, callback) {
+        return (args) => {
+            const ctx = new execution_host_1.ExecutionContextHost(args, instance && instance.constructor, callback);
+            ctx.setType(contextType);
+            return ctx;
+        };
+    }
+}
+exports.ContextUtils = ContextUtils;

package/helpers/extends-metadata.helper.d.ts

@@ -0,0 +1 @@
+export declare function extendArrayMetadata<T extends Array<unknown>>(key: string, metadata: T, target: Function): void;

package/helpers/extends-metadata.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendArrayMetadata = void 0;
+function extendArrayMetadata(key, metadata, target) {
+    const previousValue = Reflect.getMetadata(key, target) || [];
+    const value = [...previousValue, ...metadata];
+    Reflect.defineMetadata(key, value, target);
+}
+exports.extendArrayMetadata = extendArrayMetadata;

package/helpers/flatten.helper.d.ts

@@ -0,0 +1 @@
+export declare function flatten<T extends Array<unknown> = any>(arr: T): T extends Array<infer R> ? R : never;

package/helpers/flatten.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = void 0;
+function flatten(arr) {
+    // @ts-ignore
+    const flat = [].concat(...arr);
+    return flat.some(Array.isArray) ? flatten(flat) : flat;
+}
+exports.flatten = flatten;

package/helpers/messages.helper.d.ts

@@ -0,0 +1,2 @@
+export declare const MODULE_INIT_MESSAGE: (text: TemplateStringsArray, module: string) => string;
+export declare const INVALID_EXECUTION_CONTEXT: (methodName: string, currentContext: string) => string;

package/helpers/messages.helper.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_EXECUTION_CONTEXT = exports.MODULE_INIT_MESSAGE = void 0;
+const MODULE_INIT_MESSAGE = (text, module) => `${module} dependencies initialized`;
+exports.MODULE_INIT_MESSAGE = MODULE_INIT_MESSAGE;
+const INVALID_EXECUTION_CONTEXT = (methodName, currentContext) => `Calling ${methodName} is not allowed in this context. Your current execution context is "${currentContext}".`;
+exports.INVALID_EXECUTION_CONTEXT = INVALID_EXECUTION_CONTEXT;

package/helpers/noop.helper.d.ts

@@ -0,0 +1 @@
+export declare const noop: () => void;

package/helpers/noop.helper.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = void 0;
+const noop = () => { };
+exports.noop = noop;

package/helpers/random-string-generator.helper.d.ts

@@ -0,0 +1 @@
+export declare const randomStringGenerator: () => string;

package/helpers/random-string-generator.helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomStringGenerator = void 0;
+const uid_1 = require("uid");
+const randomStringGenerator = () => (0, uid_1.uid)(21);
+exports.randomStringGenerator = randomStringGenerator;

package/helpers/rethrow.helper.d.ts

@@ -0,0 +1 @@
+export declare const rethrow: (err: unknown) => never;

package/helpers/rethrow.helper.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rethrow = void 0;
+const rethrow = (err) => {
+    throw err;
+};
+exports.rethrow = rethrow;

package/helpers/shared.helper.d.ts

@@ -0,0 +1,10 @@
+export declare const isUndefined: (obj: any) => obj is undefined;
+export declare const isNull: (val: any) => val is null | undefined;
+export declare const isObject: (fn: any) => fn is object;
+export declare const isFunction: (val: any) => val is Function;
+export declare const isString: (val: any) => val is string;
+export declare const isNumber: (val: any) => val is number;
+export declare const isConstructor: (val: any) => boolean;
+export declare const isEmpty: (array: any) => boolean;
+export declare const isSymbol: (val: any) => val is symbol;
+export declare const isPlainObject: (fn: any) => fn is object;

package/helpers/shared.helper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = exports.isSymbol = exports.isEmpty = exports.isConstructor = exports.isNumber = exports.isString = exports.isFunction = exports.isObject = exports.isNull = exports.isUndefined = void 0;
+const isUndefined = (obj) => typeof obj === "undefined";
+exports.isUndefined = isUndefined;
+const isNull = (val) => (0, exports.isUndefined)(val) || val === null;
+exports.isNull = isNull;
+const isObject = (fn) => !(0, exports.isNull)(fn) && typeof fn === "object";
+exports.isObject = isObject;
+const isFunction = (val) => typeof val === "function";
+exports.isFunction = isFunction;
+const isString = (val) => typeof val === "string";
+exports.isString = isString;
+const isNumber = (val) => typeof val === "number";
+exports.isNumber = isNumber;
+const isConstructor = (val) => val === "constructor";
+exports.isConstructor = isConstructor;
+const isEmpty = (array) => !(array && array.length > 0);
+exports.isEmpty = isEmpty;
+const isSymbol = (val) => typeof val === "symbol";
+exports.isSymbol = isSymbol;
+const isPlainObject = (fn) => {
+    if (!(0, exports.isObject)(fn))
+        return false;
+    const proto = Object.getPrototypeOf(fn);
+    if (proto === null)
+        return true;
+    const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+    return (typeof ctor === "function" &&
+        ctor instanceof ctor &&
+        Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
+};
+exports.isPlainObject = isPlainObject;

package/helpers/silent.helper.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from "@venok/core/services/logger.service";
+export declare class SilentLogger extends Logger {
+    log: () => void;
+    error: () => void;
+    warn: () => void;
+    debug: () => void;
+    verbose: () => void;
+    fatal: () => void;
+    setLogLevels: () => void;
+}

package/helpers/silent.helper.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SilentLogger = void 0;
+const logger_service_1 = require("@venok/core/services/logger.service");
+const noop_helper_1 = require("@venok/core/helpers/noop.helper");
+class SilentLogger extends logger_service_1.Logger {
+    constructor() {
+        super(...arguments);
+        this.log = noop_helper_1.noop;
+        this.error = noop_helper_1.noop;
+        this.warn = noop_helper_1.noop;
+        this.debug = noop_helper_1.noop;
+        this.verbose = noop_helper_1.noop;
+        this.fatal = noop_helper_1.noop;
+        this.setLogLevels = noop_helper_1.noop;
+    }
+}
+exports.SilentLogger = SilentLogger;

package/helpers/transient.helper.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken } from "@venok/core/interfaces";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+/**
+ * Returns the instances which are transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+export declare function getTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];
+/**
+ * Returns the instances which are not transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+export declare function getNonTransientInstances(instances: [InjectionToken, InstanceWrapper][]): InstanceWrapper[];

package/helpers/transient.helper.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNonTransientInstances = exports.getTransientInstances = void 0;
+const flatten_helper_1 = require("@venok/core/helpers/flatten.helper");
+/**
+ * Returns the instances which are transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+function getTransientInstances(instances) {
+    return (0, flatten_helper_1.flatten)(instances
+        .filter(([_, wrapper]) => wrapper.isDependencyTreeStatic())
+        .map(([_, wrapper]) => wrapper.getStaticTransientInstances()))
+        .filter(Boolean)
+        .map(({ instance }) => instance);
+}
+exports.getTransientInstances = getTransientInstances;
+/**
+ * Returns the instances which are not transient
+ * @param instances The instances which should be checked whether they are transient
+ */
+function getNonTransientInstances(instances) {
+    return instances
+        .filter(([key, wrapper]) => wrapper.isDependencyTreeStatic() && !wrapper.isTransient)
+        .map(([key, { instance }]) => instance);
+}
+exports.getNonTransientInstances = getNonTransientInstances;

package/helpers/uuid.helper.d.ts

@@ -0,0 +1,15 @@
+export declare enum UuidFactoryMode {
+    Random = "random",
+    Deterministic = "deterministic"
+}
+export declare class DeterministicUuidRegistry {
+    private static readonly registry;
+    static get(str: string, inc?: number): string;
+    static clear(): void;
+    private static hashCode;
+}
+export declare class UuidFactory {
+    #private;
+    static set mode(value: UuidFactoryMode);
+    static get(key?: string): string;
+}

package/helpers/uuid.helper.js

@@ -0,0 +1,54 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _UuidFactory_mode;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidFactory = exports.DeterministicUuidRegistry = exports.UuidFactoryMode = void 0;
+const random_string_generator_helper_1 = require("@venok/core/helpers/random-string-generator.helper");
+var UuidFactoryMode;
+(function (UuidFactoryMode) {
+    UuidFactoryMode["Random"] = "random";
+    UuidFactoryMode["Deterministic"] = "deterministic";
+})(UuidFactoryMode || (exports.UuidFactoryMode = UuidFactoryMode = {}));
+class DeterministicUuidRegistry {
+    static get(str, inc = 0) {
+        const id = inc ? this.hashCode(`${str}_${inc}`) : this.hashCode(str);
+        if (this.registry.has(id))
+            return this.get(str, inc + 1);
+        this.registry.set(id, true);
+        return id;
+    }
+    static clear() {
+        this.registry.clear();
+    }
+    static hashCode(s) {
+        let h = 0;
+        for (let i = 0; i < s.length; i++)
+            h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+        return h.toString();
+    }
+}
+exports.DeterministicUuidRegistry = DeterministicUuidRegistry;
+DeterministicUuidRegistry.registry = new Map();
+class UuidFactory {
+    static set mode(value) {
+        __classPrivateFieldSet(_a, _a, value, "f", _UuidFactory_mode);
+    }
+    static get(key = "") {
+        return __classPrivateFieldGet(_a, _a, "f", _UuidFactory_mode) === UuidFactoryMode.Deterministic
+            ? DeterministicUuidRegistry.get(key)
+            : (0, random_string_generator_helper_1.randomStringGenerator)();
+    }
+}
+exports.UuidFactory = UuidFactory;
+_a = UuidFactory;
+_UuidFactory_mode = { value: UuidFactoryMode.Random };

package/helpers/validate-each.helper.d.ts

@@ -0,0 +1,8 @@
+export declare class InvalidDecoratorItemException extends Error {
+    private readonly msg;
+    constructor(decorator: string, item: string, context: string);
+    what(): string;
+}
+export declare function validateEach(context: {
+    name: string;
+}, arr: any[], predicate: Function, decorator: string, item: string): boolean;

package/helpers/validate-each.helper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEach = exports.InvalidDecoratorItemException = void 0;
+class InvalidDecoratorItemException extends Error {
+    constructor(decorator, item, context) {
+        const message = `Invalid ${item} passed to ${decorator}() decorator (${context}).`;
+        super(message);
+        this.msg = message;
+    }
+    what() {
+        return this.msg;
+    }
+}
+exports.InvalidDecoratorItemException = InvalidDecoratorItemException;
+function validateEach(context, arr, predicate, decorator, item) {
+    if (!context || !context.name) {
+        return true;
+    }
+    const errors = arr.some((str) => !predicate(str));
+    if (errors) {
+        throw new InvalidDecoratorItemException(decorator, item, context.name);
+    }
+    return true;
+}
+exports.validateEach = validateEach;

package/hooks/before-app-shutdown.hook.d.ts

@@ -0,0 +1,9 @@
+import { Module } from "@venok/core/injector/module/module";
+/**
+ * Calls the `beforeApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal The signal which caused the shutdown
+ */
+export declare function callBeforeAppShutdownHook(module: Module, signal?: string): Promise<void>;

package/hooks/before-app-shutdown.hook.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBeforeAppShutdownHook = void 0;
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const transient_helper_1 = require("@venok/core/helpers/transient.helper");
+/**
+ * Checks if the given instance has the `beforeApplicationShutdown` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasBeforeApplicationShutdownHook(instance) {
+    return (0, shared_helper_1.isFunction)(instance.beforeApplicationShutdown);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances, signal) {
+    return instances
+        .filter((instance) => !(0, shared_helper_1.isNull)(instance))
+        .filter(hasBeforeApplicationShutdownHook)
+        .map(async (instance) => instance.beforeApplicationShutdown(signal));
+}
+/**
+ * Calls the `beforeApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal The signal which caused the shutdown
+ */
+async function callBeforeAppShutdownHook(module, signal) {
+    const providers = module.getNonAliasProviders();
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [...providers, ...module.injectables];
+    const nonTransientInstances = (0, transient_helper_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances, signal));
+    const transientInstances = (0, transient_helper_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances, signal));
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasBeforeApplicationShutdownHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.beforeApplicationShutdown(signal);
+    }
+}
+exports.callBeforeAppShutdownHook = callBeforeAppShutdownHook;

package/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './on-app-bootstrap.hook';
+export * from './on-app-shutdown.hook';
+export * from './on-module-destroy.hook';
+export * from './on-module-init.hook';
+export * from './before-app-shutdown.hook';

package/hooks/index.js

@@ -0,0 +1,21 @@
+"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("./on-app-bootstrap.hook"), exports);
+__exportStar(require("./on-app-shutdown.hook"), exports);
+__exportStar(require("./on-module-destroy.hook"), exports);
+__exportStar(require("./on-module-init.hook"), exports);
+__exportStar(require("./before-app-shutdown.hook"), exports);

package/hooks/on-app-bootstrap.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from "@venok/core/injector/module/module";
+/**
+ * Calls the `onApplicationBootstrap` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleBootstrapHook(module: Module): Promise<any>;