@venok/integration 2.0.0

package/dist/configurable/constants.js

@@ -0,0 +1,26 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/configurable/constants.ts
+var DEFAULT_METHOD_KEY = "register";
+var DEFAULT_FACTORY_CLASS_METHOD_KEY = "create";
+var ASYNC_METHOD_SUFFIX = "Async";
+var CONFIGURABLE_MODULE_ID = "CONFIGURABLE_MODULE_ID";
+export {
+  DEFAULT_METHOD_KEY,
+  DEFAULT_FACTORY_CLASS_METHOD_KEY,
+  CONFIGURABLE_MODULE_ID,
+  ASYNC_METHOD_SUFFIX
+};

package/dist/configurable/helpers/generate-options-injection-token.helper.js

@@ -0,0 +1,24 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/configurable/helpers/generate-options-injection-token.helper.ts
+import { randomStringGenerator } from "@venok/core";
+function generateOptionsInjectionToken() {
+  const hash = randomStringGenerator();
+  return `CONFIGURABLE_MODULE_OPTIONS[${hash}]`;
+}
+export {
+  generateOptionsInjectionToken
+};

package/dist/configurable/helpers/get-injection-providers.helper.js

@@ -0,0 +1,34 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/configurable/helpers/get-injection-providers.helper.ts
+import { isUndefined } from "@venok/core";
+function isOptionalFactoryDependency(value) {
+  return !isUndefined(value.token) && !isUndefined(value.optional) && !value.prototype;
+}
+var mapInjectToTokens = (t) => isOptionalFactoryDependency(t) ? t.token : t;
+function getInjectionProviders(providers, tokens) {
+  const result = [];
+  let search = tokens.map(mapInjectToTokens);
+  while (search.length > 0) {
+    const match = (providers ?? []).filter((p) => !result.includes(p) && (search.includes(p) || search.includes(p?.provide)));
+    result.push(...match);
+    search = match.filter((p) => p?.inject).map((p) => p.inject).flat().map(mapInjectToTokens);
+  }
+  return result;
+}
+export {
+  getInjectionProviders
+};

package/dist/configurable/helpers/index.js

@@ -0,0 +1,3 @@
+// packages/integration/src/configurable/helpers/index.ts
+export * from "./generate-options-injection-token.helper.js";
+export * from "./get-injection-providers.helper.js";

package/dist/configurable/index.js

@@ -0,0 +1,3 @@
+// packages/integration/src/configurable/index.ts
+export * from "./constants.js";
+export * from "./module.builder.js";

package/dist/configurable/module.builder.js

@@ -0,0 +1,169 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/configurable/module.builder.ts
+import { Logger, randomStringGenerator } from "@venok/core";
+import { generateOptionsInjectionToken } from "../configurable/helpers/generate-options-injection-token.helper.js";
+import { ASYNC_METHOD_SUFFIX, CONFIGURABLE_MODULE_ID, DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from "../configurable/constants.js";
+import { getInjectionProviders } from "../configurable/helpers/get-injection-providers.helper.js";
+
+class ConfigurableModuleBuilder {
+  options;
+  staticMethodKey;
+  factoryClassMethodKey;
+  extras;
+  transformModuleDefinition;
+  logger = new Logger(ConfigurableModuleBuilder.name);
+  constructor(options = {}, parentBuilder) {
+    this.options = options;
+    if (parentBuilder) {
+      this.staticMethodKey = parentBuilder.staticMethodKey;
+      this.factoryClassMethodKey = parentBuilder.factoryClassMethodKey;
+      this.transformModuleDefinition = parentBuilder.transformModuleDefinition;
+      this.extras = parentBuilder.extras;
+    }
+  }
+  setExtras(extras, transformDefinition = (def) => def) {
+    const builder = new ConfigurableModuleBuilder(this.options, this);
+    builder.extras = extras;
+    builder.transformModuleDefinition = transformDefinition;
+    return builder;
+  }
+  setClassMethodName(key) {
+    const builder = new ConfigurableModuleBuilder(this.options, this);
+    builder.staticMethodKey = key;
+    return builder;
+  }
+  setFactoryMethodName(key) {
+    const builder = new ConfigurableModuleBuilder(this.options, this);
+    builder.factoryClassMethodKey = key;
+    return builder;
+  }
+  build() {
+    this.staticMethodKey ??= DEFAULT_METHOD_KEY;
+    this.factoryClassMethodKey ??= DEFAULT_FACTORY_CLASS_METHOD_KEY;
+    this.options.optionsInjectionToken ??= this.options.moduleName ? this.constructInjectionTokenString() : generateOptionsInjectionToken();
+    this.transformModuleDefinition ??= (definition) => definition;
+    return {
+      ConfigurableModuleClass: this.createConfigurableModuleCls(),
+      MODULE_OPTIONS_TOKEN: this.options.optionsInjectionToken,
+      ASYNC_OPTIONS_TYPE: this.createTypeProxy("ASYNC_OPTIONS_TYPE"),
+      OPTIONS_TYPE: this.createTypeProxy("OPTIONS_TYPE")
+    };
+  }
+  constructInjectionTokenString() {
+    const moduleNameInSnakeCase = (this.options.moduleName ?? randomStringGenerator()).trim().split(/(?=[A-Z])/).join("_").toUpperCase();
+    return `${moduleNameInSnakeCase}_MODULE_OPTIONS`;
+  }
+  createConfigurableModuleCls() {
+    const self = this;
+    const asyncMethodKey = this.staticMethodKey + ASYNC_METHOD_SUFFIX;
+
+    class InternalModuleClass {
+      static [self.staticMethodKey](options) {
+        const providers = [
+          {
+            provide: self.options.optionsInjectionToken,
+            useValue: this.omitExtras(options, self.extras)
+          }
+        ];
+        if (self.options.alwaysTransient) {
+          providers.push({
+            provide: CONFIGURABLE_MODULE_ID,
+            useValue: randomStringGenerator()
+          });
+        }
+        return self.transformModuleDefinition({
+          module: this,
+          providers
+        }, {
+          ...self.extras,
+          ...options
+        });
+      }
+      static [asyncMethodKey](options) {
+        const providers = this.createAsyncProviders(options);
+        if (self.options.alwaysTransient) {
+          providers.push({
+            provide: CONFIGURABLE_MODULE_ID,
+            useValue: randomStringGenerator()
+          });
+        }
+        return self.transformModuleDefinition({
+          module: this,
+          imports: options.imports || [],
+          providers
+        }, {
+          ...self.extras,
+          ...options
+        });
+      }
+      static omitExtras(input, extras) {
+        if (!extras)
+          return input;
+        const moduleOptions = {};
+        const extrasKeys = Object.keys(extras);
+        Object.keys(input).filter((key) => !extrasKeys.includes(key)).forEach((key) => {
+          moduleOptions[key] = input[key];
+        });
+        return moduleOptions;
+      }
+      static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+          if (options.inject && options.provideInjectionTokensFrom) {
+            return [
+              this.createAsyncOptionsProvider(options),
+              ...getInjectionProviders(options.provideInjectionTokensFrom, options.inject)
+            ];
+          }
+          return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+          this.createAsyncOptionsProvider(options),
+          {
+            provide: options.useClass,
+            useClass: options.useClass
+          }
+        ];
+      }
+      static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+          return {
+            provide: self.options.optionsInjectionToken,
+            useFactory: options.useFactory,
+            inject: options.inject || []
+          };
+        }
+        return {
+          provide: self.options.optionsInjectionToken,
+          useFactory: async (optionsFactory) => await optionsFactory[self.factoryClassMethodKey](),
+          inject: [options.useExisting || options.useClass]
+        };
+      }
+    }
+    return InternalModuleClass;
+  }
+  createTypeProxy(typeName) {
+    const proxy = new Proxy({}, {
+      get: () => {
+        throw new Error(`"${typeName}" is not supposed to be used as a value.`);
+      }
+    });
+    return proxy;
+  }
+}
+export {
+  ConfigurableModuleBuilder
+};

package/dist/exceptions/index.js

@@ -0,0 +1,3 @@
+// packages/integration/src/exceptions/index.ts
+export * from "./invalid-middleware.exception.js";
+export * from "./invalid-middleware-configuration.exception.js";

package/dist/exceptions/invalid-middleware-configuration.exception.js

@@ -0,0 +1,27 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/exceptions/invalid-middleware-configuration.exception.ts
+import { RuntimeException } from "@venok/core";
+import { INVALID_MIDDLEWARE_CONFIGURATION } from "../exceptions/messages.js";
+
+class InvalidMiddlewareConfigurationException extends RuntimeException {
+  constructor() {
+    super(INVALID_MIDDLEWARE_CONFIGURATION);
+  }
+}
+export {
+  InvalidMiddlewareConfigurationException
+};

package/dist/exceptions/invalid-middleware.exception.js

@@ -0,0 +1,27 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/exceptions/invalid-middleware.exception.ts
+import { RuntimeException } from "@venok/core";
+import { INVALID_MIDDLEWARE_MESSAGE } from "../exceptions/messages.js";
+
+class InvalidMiddlewareException extends RuntimeException {
+  constructor(name) {
+    super(INVALID_MIDDLEWARE_MESSAGE`${name}`);
+  }
+}
+export {
+  InvalidMiddlewareException
+};

package/dist/exceptions/messages.js

@@ -0,0 +1,22 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/exceptions/messages.ts
+var INVALID_MIDDLEWARE_CONFIGURATION = `An invalid middleware configuration has been passed inside the module 'configure()' method.`;
+var INVALID_MIDDLEWARE_MESSAGE = (text, name) => `The middleware doesn't provide the 'use' method (${name})`;
+export {
+  INVALID_MIDDLEWARE_MESSAGE,
+  INVALID_MIDDLEWARE_CONFIGURATION
+};

package/dist/index.d.ts

@@ -0,0 +1,367 @@
+/**
+* Thanks for using Venloc Venok <3
+* https://github.com/venloc-tech/svm
+*/
+import { DynamicModule as DynamicModule$1 } from '@venok/core/index.js';
+import * as _venok_core from '@venok/core';
+import { ModuleMetadata, Type, FactoryProvider, Provider, DynamicModule, Logger, ExternalContextOptions, VenokExceptionFilterContext, VenokContextCreator, InjectionToken, InstanceWrapper, Injector, CoreModule, VenokContainer, ModulesContainer, CustomDecorator, Reflector, MetadataScanner, VenokParamsFactoryInterface } from '@venok/core';
+
+declare const DEFAULT_METHOD_KEY = "register";
+declare const DEFAULT_FACTORY_CLASS_METHOD_KEY = "create";
+declare const ASYNC_METHOD_SUFFIX = "Async";
+declare const CONFIGURABLE_MODULE_ID = "CONFIGURABLE_MODULE_ID";
+
+/**
+ * Interface that must be implemented by the module options factory class.
+ * Method key varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+type ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey extends string> = Record<`${FactoryClassMethodKey}`, () => Promise<ModuleOptions> | ModuleOptions>;
+/**
+ * Interface that represents the module async options object
+ * Factory method name varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+interface ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY> extends Pick<ModuleMetadata, "imports"> {
+    /**
+     * Injection token resolving to an existing provider. The provider must implement
+     * the corresponding interface.
+     */
+    useExisting?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Injection token resolving to a class that will be instantiated as a provider.
+     * The class must implement the corresponding interface.
+     */
+    useClass?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Function returning options (or a Promise resolving to options) to configure the
+     * cache module.
+     */
+    useFactory?: (...args: any[]) => Promise<ModuleOptions> | ModuleOptions;
+    /**
+     * Dependencies that a Factory may inject.
+     */
+    inject?: FactoryProvider["inject"];
+    /**
+     * List of parent module's providers that will be filtered to only provide necessary
+     * providers for the 'inject' array
+     * useful to pass options to nested async modules
+     */
+    provideInjectionTokensFrom?: Provider[];
+}
+
+/**
+ * Class that represents a blueprint/prototype for a configurable Nest module.
+ * This class provides static methods for constructing dynamic modules. Their names
+ * can be controlled through the "MethodKey" type argument.
+ *
+ * @publicApi
+ */
+type ConfigurableModuleCls<ModuleOptions, MethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = object> = {
+    new (): any;
+} & Record<`${MethodKey}`, (options: ModuleOptions & Partial<ExtraModuleDefinitionOptions>) => DynamicModule> & Record<`${MethodKey}Async`, (options: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & Partial<ExtraModuleDefinitionOptions>) => DynamicModule>;
+
+/**
+ * Configurable module host. See properties for more details
+ *
+ * @publicApi
+ */
+interface ConfigurableModuleHost<ModuleOptions = Record<string, unknown>, MethodKey extends string = string, FactoryClassMethodKey extends string = string, ExtraModuleDefinitionOptions = object> {
+    /**
+     * Class that represents a blueprint/prototype for a configurable Nest module.
+     * This class provides static methods for constructing dynamic modules. Their names
+     * can be controlled through the "MethodKey" type argument.
+     *
+     * Your module class should inherit from this class to make the static methods available.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  // ...
+     * }
+     * ```
+     */
+    ConfigurableModuleClass: ConfigurableModuleCls<ModuleOptions, MethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Module options provider token. Can be used to inject the "options object" to
+     * providers registered within the host module.
+     */
+    MODULE_OPTIONS_TOKEN: string | symbol;
+    /**
+     * Can be used to auto-infer the compound "async module options" type.
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
+     *  return super.registerAsync(options);
+     * }
+     * ```
+     */
+    ASYNC_OPTIONS_TYPE: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & Partial<ExtraModuleDefinitionOptions>;
+    /**
+     * Can be used to auto-infer the compound "module options" type (options interface + extra module definition options).
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static register(options: typeof OPTIONS_TYPE): DynamicModule {
+     *  return super.register(options);
+     * }
+     * ```
+     */
+    OPTIONS_TYPE: ModuleOptions & Partial<ExtraModuleDefinitionOptions>;
+}
+
+/**
+ * @publicApi
+ */
+interface ConfigurableModuleBuilderOptions {
+    /**
+     * Specified what injection token should be used for the module options provider.
+     * By default, an auto-generated UUID will be used.
+     */
+    optionsInjectionToken?: string | symbol;
+    /**
+     * By default, a UUID will be used as a module options provider token.
+     * Explicitly specifying the "moduleName" will instruct the "ConfigurableModuleBuilder"
+     * to use a more descriptive provider token.
+     *
+     * For example, if `moduleName: "Cache"` then auto-generated provider token will be "CACHE_MODULE_OPTIONS".
+     */
+    moduleName?: string;
+    /**
+     * Indicates whether module should always be "transient", meaning,
+     * every time you call the static method to construct a dynamic module,
+     * regardless of what arguments you pass in, a new "unique" module will be created.
+     *
+     * @default false
+     */
+    alwaysTransient?: boolean;
+}
+/**
+ * Factory that lets you create configurable module and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+declare class ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = object> {
+    protected readonly options: ConfigurableModuleBuilderOptions;
+    protected staticMethodKey: StaticMethodKey;
+    protected factoryClassMethodKey: FactoryClassMethodKey;
+    protected extras: ExtraModuleDefinitionOptions;
+    protected transformModuleDefinition: (definition: DynamicModule$1, extraOptions: ExtraModuleDefinitionOptions) => DynamicModule$1;
+    protected readonly logger: Logger;
+    constructor(options?: ConfigurableModuleBuilderOptions, parentBuilder?: ConfigurableModuleBuilder<ModuleOptions>);
+    /**
+     * Registers the "extras" object (a set of extra options that can be used to modify the dynamic module definition).
+     * Values you specify within the "extras" object will be used as default values (that can be overridden by module consumers).
+     *
+     * This method also applies the so-called "module definition transform function" that takes the auto-generated
+     * dynamic module object ("DynamicModule") and the actual consumer "extras" object as input parameters.
+     * The "extras" object consists of values explicitly specified by module consumers and default values.
+     *
+     * @example
+     * ```typescript
+     * .setExtras<{ isGlobal?: boolean }>({ isGlobal: false }, (definition, extras) =>
+     *    ({ ...definition, global: extras.isGlobal })
+     * )
+     * ```
+     */
+    setExtras<ExtraModuleDefinitionOptions>(extras: ExtraModuleDefinitionOptions, transformDefinition?: (definition: DynamicModule$1, extras: ExtraModuleDefinitionOptions) => DynamicModule$1): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Dynamic module must expose public static methods that let you pass in
+     * configuration parameters (control the module's behavior from the outside).
+     * Some frequently used names that you may have seen in other module are:
+     * "forRoot", "forFeature", "register", "configure".
+     *
+     * This method "setClassMethodName" lets you specify the name of the
+     * method that will be auto-generated.
+     *
+     * @param key name of the method
+     */
+    setClassMethodName<StaticMethodKey extends string>(key: StaticMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Asynchronously configured module (that rely on other module, i.e. "ConfigModule")
+     * let you pass the configuration factory class that will be registered and instantiated as a provider.
+     * This provider then will be used to retrieve the module's configuration. To provide the configuration,
+     * the corresponding factory method must be implemented.
+     *
+     * This method ("setFactoryMethodName") lets you control what method name will have to be
+     * implemented by the config factory (default is "create").
+     *
+     * @param key name of the method
+     */
+    setFactoryMethodName<FactoryClassMethodKey extends string>(key: FactoryClassMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable module. See "ConfigurableModuleHost" interface for more details.
+     */
+    build(): ConfigurableModuleHost<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    private constructInjectionTokenString;
+    private createConfigurableModuleCls;
+    private createTypeProxy;
+}
+
+interface BaseMiddlewareConfiguration<MiddlewareType = any, ToType = any> {
+    middleware: MiddlewareType;
+    to: (string | Type | ToType)[];
+    exclude?: (string | ToType)[];
+}
+
+/**
+ *
+ * @publicApi
+ */
+interface VenokMiddleware {
+    use(...args: any[]): any;
+}
+
+/**
+ * @publicApi
+ */
+interface FilterByInclude {
+    /**
+     * List of modules to include (whitelist) into the discovery process.
+     */
+    include?: Function[];
+}
+/**
+ * @publicApi
+ */
+interface FilterByMetadataKey {
+    /**
+     * A key to filter controllers and providers by.
+     * Only instance wrappers with the specified metadata key will be returned.
+     */
+    metadataKey?: string;
+}
+/**
+ * @publicApi
+ */
+type DiscoveryOptions = FilterByInclude | FilterByMetadataKey;
+
+type ExplorerSettings = Partial<{
+    contextType: string;
+    isRequestScopeSupported: boolean;
+    requestContextArgIndex: number;
+    options: ExternalContextOptions;
+    exceptionsFilterClass: typeof VenokExceptionFilterContext;
+    contextCreatorClass: typeof VenokContextCreator;
+    metadataKey: string;
+}>;
+
+declare class MiddlewareContainer {
+    private readonly middleware;
+    private readonly configurationSets;
+    getMiddlewareCollection(moduleKey: string): Map<InjectionToken, InstanceWrapper>;
+    getConfigurations(): Map<string, Set<BaseMiddlewareConfiguration>>;
+    insertConfig(configList: BaseMiddlewareConfiguration[], moduleKey: string): void;
+    private getTargetConfig;
+}
+
+declare class MiddlewareResolver {
+    private readonly middlewareContainer;
+    private readonly injector;
+    constructor(middlewareContainer: MiddlewareContainer, injector: Injector);
+    resolveInstances(moduleRef: CoreModule, moduleName: string): Promise<void>;
+    private resolveMiddlewareInstance;
+}
+
+type VenokContextCallback = (...args: any[]) => void | Promise<void>;
+declare abstract class MiddlewareService<MiddlewareConfiguration extends BaseMiddlewareConfiguration> {
+    readonly container: VenokContainer;
+    protected index: number;
+    protected type: string;
+    protected readonly exceptionsFilter: VenokExceptionFilterContext;
+    private readonly venokProxy;
+    private readonly exceptionFiltersCache;
+    protected readonly logger: Logger;
+    protected readonly injector: Injector;
+    protected readonly middlewareContainer: MiddlewareContainer;
+    protected readonly resolver: MiddlewareResolver;
+    constructor(container: VenokContainer);
+    explore(middlewareClass: any): Promise<void>;
+    private loadConfiguration;
+    protected abstract getMiddlewareBuilder(): any;
+    build(): Promise<void>;
+    private registerConfig;
+    private registerMiddleware;
+    protected abstract registerHandler(info: MiddlewareConfiguration["to"][number], proxy: (...args: any[]) => any, config: MiddlewareConfiguration): Promise<void> | void;
+    protected createCallback(wrapper: InstanceWrapper<VenokMiddleware>, moduleRef: CoreModule, collection: Map<InjectionToken, InstanceWrapper>): Promise<VenokContextCallback>;
+    private createProxy;
+}
+
+/**
+ * @publicApi
+ */
+declare class DiscoveryService {
+    private readonly modulesContainer;
+    constructor(modulesContainer: ModulesContainer);
+    /**
+     * 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?: CoreModule[]): 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 CustomDecorator>(decorator: T, instanceWrapper: InstanceWrapper, methodKey?: string): T extends CustomDecorator<infer R> ? R | undefined : T | undefined;
+    /**
+     * Returns a list of modules to be used for discovery.
+     */
+    protected getModules(options?: DiscoveryOptions): CoreModule[];
+    private includeWhitelisted;
+}
+
+declare abstract class ExplorerService<T = any> extends Reflector {
+    protected readonly container: VenokContainer;
+    protected readonly discoveryService: DiscoveryService;
+    protected readonly metadataScanner: MetadataScanner;
+    protected abstract readonly paramsFactory: VenokParamsFactoryInterface;
+    protected readonly type: string;
+    protected readonly withRequestScope: boolean;
+    protected readonly requestArgIndex: number;
+    protected readonly options: Omit<ExternalContextOptions, "callback">;
+    protected readonly metadataKey: string;
+    protected readonly exceptionsFilterClass: typeof VenokExceptionFilterContext;
+    protected readonly contextCreatorClass: typeof VenokContextCreator;
+    protected readonly exceptionsFilter: VenokExceptionFilterContext;
+    protected readonly contextCreator: VenokContextCreator;
+    protected readonly wrappers: InstanceWrapper[];
+    private readonly exceptionFiltersCache;
+    constructor(container: VenokContainer, discoveryService: DiscoveryService, metadataScanner: MetadataScanner);
+    explore(metadataKey: string): T[];
+    protected abstract getSettings(): ExplorerSettings;
+    protected abstract filterProperties(wrapper: InstanceWrapper, metadataKey: string): NonNullable<T> | undefined;
+    protected createCallback(wrapper: InstanceWrapper, methodName: string): (...args: any[]) => Promise<any>;
+    protected createContextCallback(instance: object, callback: (...args: any[]) => any, methodName: string, contextId?: _venok_core.ContextId, inquirerId?: string | undefined): (...args: any[]) => Promise<any>;
+    protected getContextArgForRequest(args: any[]): any;
+    private createRequestScopeContextCallback;
+}
+
+/**
+ * @publicApi
+ */
+declare class IntegrationModule {
+}
+
+export { ASYNC_METHOD_SUFFIX, type BaseMiddlewareConfiguration, CONFIGURABLE_MODULE_ID, type ConfigurableModuleAsyncOptions, ConfigurableModuleBuilder, type ConfigurableModuleBuilderOptions, type ConfigurableModuleCls, type ConfigurableModuleHost, type ConfigurableModuleOptionsFactory, DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY, type DiscoveryOptions, DiscoveryService, ExplorerService, type ExplorerSettings, type FilterByInclude, type FilterByMetadataKey, IntegrationModule, MiddlewareContainer, MiddlewareResolver, MiddlewareService, type VenokMiddleware };

package/dist/index.js

@@ -0,0 +1,8 @@
+// packages/integration/src/index.ts
+import"reflect-metadata";
+
+export * from "./configurable/index.js";
+export * from "./interfaces/index.js";
+export * from "./middleware/index.js";
+export * from "./services/index.js";
+export * from "./integration.module.js";

package/dist/integration.module.js

@@ -0,0 +1,29 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/integration.module.ts
+import { MetadataScanner, Module } from "@venok/core";
+import { DiscoveryService } from "./services/discovery.service.js";
+class IntegrationModule {
+}
+IntegrationModule = __legacyDecorateClassTS([
+  Module({
+    providers: [MetadataScanner, DiscoveryService],
+    exports: [MetadataScanner, DiscoveryService]
+  })
+], IntegrationModule);
+export {
+  IntegrationModule
+};

package/dist/interfaces/configurable/index.js

@@ -0,0 +1,4 @@
+// packages/integration/src/interfaces/configurable/index.ts
+export * from "./async-options.interface.js";
+export * from "./cls.interface.js";
+export * from "./host.interface.js";

package/dist/interfaces/index.js

@@ -0,0 +1,4 @@
+// packages/integration/src/interfaces/index.ts
+export * from "./configurable/index.js";
+export * from "./middleware/index.js";
+export * from "./services/index.js";

package/dist/interfaces/middleware/index.js

@@ -0,0 +1,3 @@
+// packages/integration/src/interfaces/middleware/index.ts
+export * from "./configuration.interface.js";
+export * from "./middleware.interface.js";

package/dist/interfaces/services/index.js

@@ -0,0 +1,3 @@
+// packages/integration/src/interfaces/services/index.ts
+export * from "./discovery.interface.js";
+export * from "./explorer.interface.js";

package/dist/middleware/container.js

@@ -0,0 +1,59 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/middleware/container.ts
+import { getClassScope, InstanceWrapper, isDurable } from "@venok/core";
+
+class MiddlewareContainer {
+  middleware = new Map;
+  configurationSets = new Map;
+  getMiddlewareCollection(moduleKey) {
+    if (!this.middleware.has(moduleKey)) {
+      this.middleware.set(moduleKey, new Map);
+    }
+    return this.middleware.get(moduleKey);
+  }
+  getConfigurations() {
+    return this.configurationSets;
+  }
+  insertConfig(configList, moduleKey) {
+    const middleware = this.getMiddlewareCollection(moduleKey);
+    const targetConfig = this.getTargetConfig(moduleKey);
+    const configurations = configList || [];
+    const insertMiddleware = (metatype) => {
+      const token = metatype;
+      middleware.set(token, new InstanceWrapper({
+        scope: getClassScope(metatype),
+        durable: isDurable(metatype),
+        name: token?.name ?? token,
+        metatype,
+        token
+      }));
+    };
+    configurations.forEach((config) => {
+      [].concat(config.middleware).map(insertMiddleware);
+      targetConfig.add(config);
+    });
+  }
+  getTargetConfig(moduleName) {
+    if (!this.configurationSets.has(moduleName)) {
+      this.configurationSets.set(moduleName, new Set);
+    }
+    return this.configurationSets.get(moduleName);
+  }
+}
+export {
+  MiddlewareContainer
+};

package/dist/middleware/index.js

@@ -0,0 +1,4 @@
+// packages/integration/src/middleware/index.ts
+export * from "./container.js";
+export * from "./resolver.js";
+export * from "./service.js";

package/dist/middleware/resolver.js

@@ -0,0 +1,42 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/middleware/resolver.ts
+import { STATIC_CONTEXT, isUndefined } from "@venok/core";
+
+class MiddlewareResolver {
+  middlewareContainer;
+  injector;
+  constructor(middlewareContainer, injector) {
+    this.middlewareContainer = middlewareContainer;
+    this.injector = injector;
+  }
+  async resolveInstances(moduleRef, moduleName) {
+    const middlewareMap = this.middlewareContainer.getMiddlewareCollection(moduleName);
+    const resolveInstance = async (wrapper) => this.resolveMiddlewareInstance(wrapper, middlewareMap, moduleRef);
+    await Promise.all([...middlewareMap.values()].map(resolveInstance));
+  }
+  async resolveMiddlewareInstance(wrapper, middlewareMap, moduleRef) {
+    const { metatype, token } = wrapper;
+    const targetWrapper = middlewareMap.get(token);
+    if (!targetWrapper || !isUndefined(targetWrapper.instance))
+      return;
+    targetWrapper.instance = Object.create(metatype.prototype);
+    await this.injector.loadInstance(wrapper, middlewareMap, moduleRef, STATIC_CONTEXT, wrapper);
+  }
+}
+export {
+  MiddlewareResolver
+};

package/dist/middleware/service.js

@@ -0,0 +1,134 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/middleware/service.ts
+import { ExecutionContextHost, Injectable, Injector, isUndefined, Logger, RuntimeException, STATIC_CONTEXT, VenokContainer, VenokExceptionFilterContext, VenokProxy } from "@venok/core";
+import { MiddlewareContainer } from "../middleware/container.js";
+import { MiddlewareResolver } from "../middleware/resolver.js";
+import { InvalidMiddlewareException } from "../exceptions/invalid-middleware.exception.js";
+class MiddlewareService {
+  container;
+  index = 0;
+  type = "native";
+  exceptionsFilter;
+  venokProxy = new VenokProxy;
+  exceptionFiltersCache = new WeakMap;
+  logger = new Logger(MiddlewareService.name, { timestamp: true });
+  injector = new Injector;
+  middlewareContainer = new MiddlewareContainer;
+  resolver = new MiddlewareResolver(this.middlewareContainer, this.injector);
+  constructor(container) {
+    this.container = container;
+    console.log("initialized");
+    this.exceptionsFilter = new VenokExceptionFilterContext(this.container, this.container.applicationConfig);
+  }
+  async explore(middlewareClass) {
+    const modules = this.container.getModules();
+    const moduleEntries = [...modules.entries()];
+    const loadMiddlewareConfiguration = async ([moduleName, moduleRef]) => {
+      await this.loadConfiguration(moduleRef, moduleName, middlewareClass);
+      await this.resolver.resolveInstances(moduleRef, moduleName);
+    };
+    await Promise.all(moduleEntries.map(loadMiddlewareConfiguration));
+  }
+  async loadConfiguration(moduleRef, moduleKey, middlewareClass) {
+    const { instance } = moduleRef;
+    if (!instance.configure)
+      return;
+    if (!(instance instanceof middlewareClass))
+      return;
+    const builder = this.getMiddlewareBuilder();
+    try {
+      await instance.configure(builder);
+    } catch (err) {
+      const warningMessage = `Warning! "${moduleRef.name}" module exposes a "configure" method that throws an exception in the preview mode` + ` (possibly due to missing dependencies). Note: you can ignore this message, just be aware that some of those conditional middlewares will not be reflected in your graph.`;
+      this.logger.warn(warningMessage);
+      throw err;
+    }
+    const config = builder.build();
+    this.middlewareContainer.insertConfig(config, moduleKey);
+  }
+  async build() {
+    const configs = this.middlewareContainer.getConfigurations();
+    const registerAllConfigs = async (moduleKey, middlewareConfig) => {
+      for (const config of middlewareConfig)
+        await this.registerConfig(config, moduleKey);
+    };
+    const entriesSortedByDistance = [...configs.entries()].sort(([moduleA], [moduleB]) => {
+      return this.container.getModuleByKey(moduleA).distance - this.container.getModuleByKey(moduleB).distance;
+    });
+    for (const [moduleRef, moduleConfigurations] of entriesSortedByDistance) {
+      await registerAllConfigs(moduleRef, [...moduleConfigurations]);
+    }
+  }
+  async registerConfig(config, moduleKey) {
+    const { to } = config;
+    for (const info of to)
+      await this.registerMiddleware(info, moduleKey, config);
+  }
+  async registerMiddleware(to, moduleKey, config) {
+    const middlewareCollection = [].concat(config.middleware);
+    const collection = this.middlewareContainer.getMiddlewareCollection(moduleKey);
+    const moduleRef = this.container.getModuleByKey(moduleKey);
+    for (const metatype of middlewareCollection) {
+      const instanceWrapper = collection.get(metatype);
+      if (isUndefined(instanceWrapper))
+        throw new RuntimeException;
+      if (instanceWrapper.isTransient)
+        return;
+      const proxy = await this.createCallback(instanceWrapper, moduleRef, collection);
+      await this.registerHandler(to, proxy, config);
+    }
+  }
+  async createCallback(wrapper, moduleRef, collection) {
+    const { instance, metatype } = wrapper;
+    if (isUndefined(instance?.use))
+      throw new InvalidMiddlewareException(metatype.name);
+    const isStatic = wrapper.isDependencyTreeStatic();
+    if (isStatic)
+      return await this.createProxy(instance);
+    const isTreeDurable = wrapper.isDependencyTreeDurable();
+    return async (...args) => {
+      try {
+        const contextId = this.container.getContextId(args[this.index], isTreeDurable);
+        const contextInstance = await this.injector.loadPerContext(instance, moduleRef, collection, contextId);
+        const proxy = await this.createProxy(contextInstance, contextId);
+        return proxy(...args);
+      } catch (err) {
+        let exceptionsHandler = this.exceptionFiltersCache.get(instance.use);
+        if (!exceptionsHandler) {
+          exceptionsHandler = this.exceptionsFilter.create(instance, instance.use, undefined);
+          this.exceptionFiltersCache.set(instance.use, exceptionsHandler);
+        }
+        const host = new ExecutionContextHost(args);
+        exceptionsHandler.next(err, host);
+      }
+    };
+  }
+  async createProxy(instance, contextId = STATIC_CONTEXT) {
+    const exceptionsHandler = this.exceptionsFilter.create(instance, instance.use, undefined, contextId);
+    const middleware = instance.use.bind(instance);
+    return this.venokProxy.createProxy(middleware, exceptionsHandler, this.type);
+  }
+}
+MiddlewareService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof VenokContainer === "undefined" ? Object : VenokContainer
+  ])
+], MiddlewareService);
+export {
+  MiddlewareService
+};

package/dist/services/discovery.service.js

@@ -0,0 +1,55 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/services/discovery.service.ts
+import { flatten, Injectable, MetaHostStorage, ModulesContainer } from "@venok/core";
+class DiscoveryService {
+  modulesContainer;
+  constructor(modulesContainer) {
+    this.modulesContainer = modulesContainer;
+  }
+  getProviders(options = {}, modules = this.getModules(options)) {
+    if ("metadataKey" in options && options.metadataKey) {
+      const providers2 = MetaHostStorage.getProvidersByMetaKey(this.modulesContainer, options.metadataKey);
+      return Array.from(providers2);
+    }
+    const providers = modules.map((item) => [...item.providers.values()]);
+    return flatten(providers);
+  }
+  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);
+  }
+  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));
+  }
+}
+DiscoveryService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ModulesContainer === "undefined" ? Object : ModulesContainer
+  ])
+], DiscoveryService);
+export {
+  DiscoveryService
+};

package/dist/services/explorer.service.js

@@ -0,0 +1,123 @@
+var __legacyDecorateClassTS = 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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/integration/src/services/explorer.service.ts
+import {
+  ExecutionContextHost,
+  Injectable,
+  Injector,
+  MetadataScanner,
+  Reflector,
+  ROUTE_ARGS_METADATA,
+  STATIC_CONTEXT,
+  VenokContainer,
+  VenokContextCreator,
+  VenokExceptionFilterContext
+} from "@venok/core";
+import { DiscoveryService } from "../services/discovery.service.js";
+class ExplorerService extends Reflector {
+  container;
+  discoveryService;
+  metadataScanner;
+  type;
+  withRequestScope;
+  requestArgIndex;
+  options;
+  metadataKey;
+  exceptionsFilterClass;
+  contextCreatorClass;
+  exceptionsFilter;
+  contextCreator;
+  wrappers;
+  exceptionFiltersCache = new WeakMap;
+  constructor(container, discoveryService, metadataScanner) {
+    super();
+    this.container = container;
+    this.discoveryService = discoveryService;
+    this.metadataScanner = metadataScanner;
+    const {
+      contextType = "native",
+      contextCreatorClass = VenokContextCreator,
+      exceptionsFilterClass = VenokExceptionFilterContext,
+      isRequestScopeSupported = false,
+      options = { guards: true, filters: true, interceptors: true, callback: undefined },
+      requestContextArgIndex = 0,
+      metadataKey = ROUTE_ARGS_METADATA
+    } = this.getSettings();
+    this.options = options;
+    this.type = contextType;
+    this.metadataKey = metadataKey;
+    this.requestArgIndex = requestContextArgIndex;
+    this.contextCreatorClass = contextCreatorClass;
+    this.withRequestScope = isRequestScopeSupported;
+    this.exceptionsFilterClass = exceptionsFilterClass;
+    this.contextCreator = this.contextCreatorClass.fromContainer(container, this.contextCreatorClass, this.exceptionsFilterClass);
+    this.exceptionsFilter = new this.exceptionsFilterClass(this.container, this.container.applicationConfig);
+    this.wrappers = this.discoveryService.getProviders().filter((wrapper) => {
+      const { instance } = wrapper;
+      const prototype = instance ? Object.getPrototypeOf(instance) : null;
+      return this.withRequestScope ? instance && prototype : instance && prototype && wrapper.isDependencyTreeStatic();
+    });
+  }
+  explore(metadataKey) {
+    return this.wrappers.flatMap((wrapper) => this.filterProperties(wrapper, metadataKey)).filter(Boolean);
+  }
+  createCallback(wrapper, methodName) {
+    if (!this.withRequestScope)
+      return this.createContextCallback(wrapper.instance, wrapper.instance[methodName], methodName);
+    const isRequestScoped = !wrapper.isDependencyTreeStatic();
+    return isRequestScoped ? this.createRequestScopeContextCallback(wrapper, methodName) : this.createContextCallback(wrapper.instance, wrapper.instance[methodName], methodName);
+  }
+  createContextCallback(instance, callback, methodName, contextId = STATIC_CONTEXT, inquirerId = undefined) {
+    return this.contextCreator.create(instance, callback, methodName, this.metadataKey, this.paramsFactory, contextId, inquirerId, this.options, this.type);
+  }
+  getContextArgForRequest(args) {
+    return this.paramsFactory.exchangeKeyForValue(this.requestArgIndex, undefined, args);
+  }
+  createRequestScopeContextCallback(wrapper, methodName) {
+    const { instance } = wrapper;
+    const moduleKey = this.contextCreator.getContextModuleKey(instance.constructor);
+    const moduleRef = this.container.getModuleByKey(moduleKey);
+    const collection = moduleRef.injectables;
+    const isTreeDurable = wrapper.isDependencyTreeDurable();
+    return async (...args) => {
+      try {
+        const contextArg = this.getContextArgForRequest(args);
+        const contextId = this.container.getContextId(contextArg, isTreeDurable);
+        const contextInstance = await new Injector().loadPerContext(instance, moduleRef, collection, contextId);
+        await this.createContextCallback(contextInstance, contextInstance[methodName], methodName, contextId, wrapper.id)(...args);
+      } catch (err) {
+        let exceptionFilter = this.exceptionFiltersCache.get(instance[methodName]);
+        if (!exceptionFilter) {
+          exceptionFilter = this.exceptionsFilter.create(instance, instance[methodName], moduleKey);
+          this.exceptionFiltersCache.set(instance[methodName], exceptionFilter);
+        }
+        const host = new ExecutionContextHost(args);
+        exceptionFilter.next(err, host);
+      }
+    };
+  }
+}
+ExplorerService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof VenokContainer === "undefined" ? Object : VenokContainer,
+    typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+    typeof MetadataScanner === "undefined" ? Object : MetadataScanner
+  ])
+], ExplorerService);
+export {
+  ExplorerService
+};

package/dist/services/index.js

@@ -0,0 +1,3 @@
+// packages/integration/src/services/index.ts
+export * from "./discovery.service.js";
+export * from "./explorer.service.js";

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@venok/integration",
+  "version": "2.0.0",
+  "description": "",
+  "author": "shiz-ceo",
+  "type": "module",
+  "homepage": "",
+  "main": "index.js",
+  "files": ["package.json", "dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venokjs/venok.git",
+    "directory": "packages/integration"
+  },
+  "scripts": {
+    "build": "venok build",
+    "test": "mocha test/**/*.spec.ts"
+  },
+  "peerDependencies": {
+    "@venok/core": "1.1.0",
+    "uuid": "^13.0.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  }
+}