@nestjs-mod/common
Version:
A collection of utilities for unifying NestJS applications and modules
948 lines (947 loc) • 68.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getWrapModuleMetadataMethods = getWrapModuleMetadataMethods;
exports.getNestModuleInternalUtils = getNestModuleInternalUtils;
exports.getNestModuleDecorators = getNestModuleDecorators;
exports.createNestModule = createNestModule;
exports.collectRootNestModules = collectRootNestModules;
const tslib_1 = require("tslib");
/* eslint-disable @typescript-eslint/no-explicit-any */
const common_1 = require("@nestjs/common");
const crypto_1 = require("crypto");
const rxjs_1 = require("rxjs");
const utils_1 = require("../config-model/utils");
const utils_2 = require("../env-model/utils");
const default_context_name_1 = require("../utils/default-context-name");
const detect_provider_name_1 = require("../utils/detect-provider-name");
const is_infrastructure_1 = require("../utils/is-infrastructure");
const name_it_class_1 = require("../utils/name-it-class");
const errors_1 = require("./errors");
const types_1 = require("./types");
function getWrapModuleMetadataMethods() {
const nestModuleMetadataMethods = ['preWrapApplication', 'wrapApplication', 'postWrapApplication'];
return nestModuleMetadataMethods;
}
function getNestModuleInternalUtils({ moduleName }) {
function getFeatureEnvironmentsToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_feature_environments`;
}
function getAllFeatureEnvironmentsToken() {
return `${moduleName}_all_feature_environments`;
}
function getFeatureConfigurationsToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_feature_configurations`;
}
function getAllFeatureConfigurationsToken() {
return `${moduleName}_all_feature_configurations`;
}
function getConfigurationLoaderToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_configuration_loader`;
}
function getStaticConfigurationLoaderToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_static_configuration_loader`;
}
function getEnvironmentsLoaderToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_environments_loader`;
}
function getStaticEnvironmentsLoaderToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_static_environments_loader`;
}
function getAsyncConfigurationToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_options_async_loader`;
}
function getServiceToken(targetName, contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_service_${targetName}`;
}
function getAllModuleSettingsToken() {
return `${moduleName}_all_module_settings`;
}
function getModuleSettingsToken(contextName) {
return `${moduleName}_${(0, default_context_name_1.defaultContextName)(contextName)}_module_settings`;
}
function createUniqProvider() {
const uniqValue = (0, crypto_1.randomUUID)();
return {
provide: `${uniqValue}_uniq_provider`,
useValue: uniqValue,
};
}
return {
defaultContextName: default_context_name_1.defaultContextName,
createUniqProvider,
getEnvironmentsLoaderToken,
getStaticEnvironmentsLoaderToken,
getStaticConfigurationLoaderToken,
getConfigurationLoaderToken,
getServiceToken,
getFeatureConfigurationsToken,
getAsyncConfigurationToken,
getAllFeatureConfigurationsToken,
getFeatureEnvironmentsToken,
getAllFeatureEnvironmentsToken,
getModuleSettingsToken,
getAllModuleSettingsToken,
};
}
function getNestModuleDecorators({ moduleName }) {
const { getFeatureConfigurationsToken, getServiceToken, getAllFeatureConfigurationsToken, getFeatureEnvironmentsToken, getAllFeatureEnvironmentsToken, getModuleSettingsToken, getAllModuleSettingsToken, } = getNestModuleInternalUtils({
moduleName,
});
// TODO: not worked with ReturnType<typeof Inject>
const InjectAllModuleSettings = () => (0, common_1.Inject)(getAllModuleSettingsToken());
// TODO: not worked with ReturnType<typeof Inject>
const InjectModuleSettings = (contextName) => (0, common_1.Inject)(getModuleSettingsToken(contextName));
// TODO: not worked with ReturnType<typeof Inject>
const InjectAllFeatureEnvironments = () => (0, common_1.Inject)(getAllFeatureEnvironmentsToken());
// TODO: not worked with ReturnType<typeof Inject>
const InjectFeatureEnvironments = (contextName) => (0, common_1.Inject)(getFeatureEnvironmentsToken(contextName));
// TODO: not worked with ReturnType<typeof Inject>
const InjectAllFeatures = () => (0, common_1.Inject)(getAllFeatureConfigurationsToken());
// TODO: not worked with ReturnType<typeof Inject>
const InjectFeatures = (contextName) => (0, common_1.Inject)(getFeatureConfigurationsToken(contextName));
// TODO: not worked with ReturnType<typeof Inject>
const InjectService = (service, contextName) => (target, key, index) => {
const token = getServiceToken((0, detect_provider_name_1.detectProviderName)(service), contextName);
// TODO: not worked :( const type = Reflect.getMetadata('design:type', target, key);
return (0, common_1.Inject)(token)(target, key, index);
};
return {
InjectFeatures,
InjectService,
InjectAllFeatures,
InjectFeatureEnvironments,
InjectAllFeatureEnvironments,
InjectModuleSettings,
InjectAllModuleSettings,
};
}
///////////////////////////
// todo: fast bad hotfix for correct work staticEnvironmentsModel without staticConfigurationModel
class DummyClass {
}
function createNestModule(nestModuleMetadata) {
var InternalNestModule_1;
// todo: fast bad hotfix for correct work staticEnvironmentsModel without staticConfigurationModel
if (nestModuleMetadata.staticEnvironmentsModel && !nestModuleMetadata.staticConfigurationModel) {
nestModuleMetadata.staticConfigurationModel = DummyClass;
}
if (!nestModuleMetadata.logger) {
nestModuleMetadata.logger = new common_1.ConsoleLogger('createNestModule');
}
const forRootMethodName = nestModuleMetadata.forRootMethodName || types_1.DEFAULT_FOR_ROOT_METHOD_NAME;
const forRootAsyncMethodName = nestModuleMetadata.forRootAsyncMethodName || types_1.DEFAULT_FOR_ROOT_ASYNC_METHOD_NAME;
const forFeatureMethodName = nestModuleMetadata.forFeatureMethodName || types_1.DEFAULT_FOR_FEATURE_METHOD_NAME;
const forFeatureAsyncMethodName = nestModuleMetadata.forFeatureAsyncMethodName || types_1.DEFAULT_FOR_FEATURE_ASYNC_METHOD_NAME;
const { defaultContextName, createUniqProvider, getEnvironmentsLoaderToken, getStaticEnvironmentsLoaderToken, getStaticConfigurationLoaderToken, getConfigurationLoaderToken, getServiceToken, getFeatureConfigurationsToken, getFeatureEnvironmentsToken, getAllFeatureConfigurationsToken, getAllFeatureEnvironmentsToken, getAsyncConfigurationToken, getModuleSettingsToken, getAllModuleSettingsToken, } = getNestModuleInternalUtils({
moduleName: nestModuleMetadata.moduleName,
});
const forFeatureModules = [];
const moduleSettings = {};
const modulesByContextName = {};
const featuresConfigurationByContextName = {};
const featuresEnvironmentsByContextName = {};
const settingsModulesByContextName = {};
const getFeatureProviders = (contextName) => {
contextName = defaultContextName(contextName);
if (featuresConfigurationByContextName[contextName] === undefined) {
featuresConfigurationByContextName[contextName] = [];
}
if (featuresEnvironmentsByContextName[contextName] === undefined) {
featuresEnvironmentsByContextName[contextName] = [];
}
if (moduleSettings[contextName] === undefined) {
moduleSettings[contextName] = {};
}
return [
{
provide: getAllFeatureConfigurationsToken(),
useValue: new Proxy(featuresConfigurationByContextName, {
get(target, prop) {
if (prop !== undefined) {
return featuresConfigurationByContextName[prop];
}
else {
return featuresConfigurationByContextName;
}
},
}),
},
{
provide: getFeatureConfigurationsToken(contextName),
useValue: new Proxy(featuresConfigurationByContextName[contextName], {
get(target, prop) {
contextName = defaultContextName(contextName);
if (prop === 'length') {
return featuresConfigurationByContextName[contextName].length;
}
if (prop !== undefined) {
return featuresConfigurationByContextName[contextName][prop];
}
return target[prop];
},
}),
},
//
{
provide: getAllFeatureEnvironmentsToken(),
useValue: new Proxy(featuresEnvironmentsByContextName, {
get(target, prop) {
if (prop !== undefined) {
return featuresEnvironmentsByContextName[prop];
}
else {
return featuresEnvironmentsByContextName;
}
},
}),
},
{
provide: getFeatureEnvironmentsToken(contextName),
useValue: new Proxy(featuresEnvironmentsByContextName[contextName], {
get(target, prop) {
contextName = defaultContextName(contextName);
if (prop === 'length') {
return featuresEnvironmentsByContextName[contextName].length;
}
if (prop !== undefined) {
return featuresEnvironmentsByContextName[contextName][prop];
}
return target[prop];
},
}),
},
//
{
provide: getAllModuleSettingsToken(),
useValue: new Proxy(moduleSettings, {
get(target, prop) {
if (prop !== undefined) {
return moduleSettings[prop];
}
else {
return moduleSettings;
}
},
}),
},
{
provide: getModuleSettingsToken(contextName),
useValue: new Proxy(moduleSettings[contextName], {
get(target, prop) {
contextName = defaultContextName(contextName);
if (prop !== undefined) {
return moduleSettings[contextName]?.[prop];
}
else {
return moduleSettings[contextName];
}
},
}),
},
];
};
const getSettingsModule = (contextName) => {
let SettingsModule = class SettingsModule {
};
SettingsModule = tslib_1.__decorate([
(0, common_1.Module)({
providers: [
...(nestModuleMetadata.configurationModel ? [nestModuleMetadata.configurationModel] : []),
...(nestModuleMetadata.staticConfigurationModel ? [nestModuleMetadata.staticConfigurationModel] : []),
...getFeatureProviders(contextName),
...getFeatureProviders(),
...(nestModuleMetadata.environmentsModel ? [nestModuleMetadata.environmentsModel] : []),
...(nestModuleMetadata.staticEnvironmentsModel ? [nestModuleMetadata.staticEnvironmentsModel] : []),
],
exports: [
...(nestModuleMetadata.configurationModel ? [nestModuleMetadata.configurationModel] : []),
...(nestModuleMetadata.staticConfigurationModel ? [nestModuleMetadata.staticConfigurationModel] : []),
getAllFeatureConfigurationsToken(),
getAllFeatureEnvironmentsToken(),
getFeatureConfigurationsToken(contextName),
getFeatureConfigurationsToken(),
getFeatureEnvironmentsToken(contextName),
getFeatureEnvironmentsToken(),
getAllModuleSettingsToken(),
getModuleSettingsToken(contextName),
...(nestModuleMetadata.environmentsModel ? [nestModuleMetadata.environmentsModel] : []),
...(nestModuleMetadata.staticEnvironmentsModel ? [nestModuleMetadata.staticEnvironmentsModel] : []),
],
})
], SettingsModule);
return (0, name_it_class_1.nameItClass)(`${nestModuleMetadata.moduleName}Settings`, SettingsModule);
};
const getOrCreateSettingsModule = (contextName) => {
contextName = defaultContextName(contextName);
if (settingsModulesByContextName[contextName] === undefined) {
settingsModulesByContextName[contextName] = getSettingsModule(contextName);
}
return { contextName, module: settingsModulesByContextName[contextName] };
};
let sharedStaticConfiguration;
let sharedStaticEnvironments;
const getSharedModule = (contextName, staticConfiguration, staticEnvironments) => {
if (sharedStaticConfiguration === undefined) {
sharedStaticConfiguration = staticConfiguration;
}
if (sharedStaticEnvironments === undefined) {
sharedStaticEnvironments = staticEnvironments;
}
const { module: settingsModule } = getOrCreateSettingsModule(contextName);
const sharedProvidersArr = !nestModuleMetadata?.sharedProviders || Array.isArray(nestModuleMetadata.sharedProviders)
? nestModuleMetadata?.sharedProviders
: nestModuleMetadata.sharedProviders({
project: nestModuleMetadata.project,
contextName,
staticConfiguration,
staticEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
contextName,
}),
});
const sharedProviders = ((nestModuleMetadata.sharedProviders === undefined ? [] : sharedProvidersArr) ||
[]);
const sharedImportsArr = nestModuleMetadata?.sharedImports === undefined || Array.isArray(nestModuleMetadata.sharedImports)
? nestModuleMetadata?.sharedImports
: nestModuleMetadata.sharedImports({
project: nestModuleMetadata.project,
contextName,
settingsModule,
staticConfiguration,
staticEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
contextName,
}),
});
const sharedImports = (nestModuleMetadata.sharedImports === undefined ? [] : sharedImportsArr) || [];
const exports = [];
const providers = sharedProviders
.map((sharedService) => {
try {
const detectedProviderName = (0, detect_provider_name_1.detectProviderName)(sharedService);
if (typeof sharedService !== 'string') {
if ('provide' in sharedService) {
const providers = [
sharedService,
{
provide: getServiceToken(detectedProviderName, contextName),
useExisting: sharedService.provide,
},
];
exports.push(providers[0].provide);
exports.push(getServiceToken(detectedProviderName, contextName));
return providers;
}
if ('name' in sharedService) {
const providers = [
sharedService,
{
provide: getServiceToken(detectedProviderName, contextName),
useExisting: sharedService,
},
];
exports.push(sharedService);
exports.push(getServiceToken(detectedProviderName, contextName));
return providers;
}
}
exports.push(sharedService);
exports.push(getServiceToken(detectedProviderName, contextName));
return [sharedService];
}
catch (err) {
throw new errors_1.NestModuleError(err.message);
}
})
.filter(Boolean)
.flat();
let SharedModule = class SharedModule {
};
SharedModule = tslib_1.__decorate([
(0, common_1.Module)({
imports: [settingsModule, ...sharedImports],
providers,
exports,
})
], SharedModule);
return (0, name_it_class_1.nameItClass)(`${nestModuleMetadata.moduleName}Shared`, SharedModule);
};
const getFeatureModule = ({ contextName, staticConfiguration, staticEnvironments, }) => {
contextName = defaultContextName(contextName);
if (modulesByContextName[contextName] === undefined) {
modulesByContextName[contextName] = getSharedModule(contextName, staticConfiguration, staticEnvironments);
}
if (moduleSettings[contextName] === undefined) {
moduleSettings[contextName] = {};
}
return {
contextName,
module: modulesByContextName[contextName],
featureConfiguration: undefined,
featureEnvironments: undefined,
};
};
const getOrCreateFeatureModule = async ({ contextName, featureModuleName, featureConfiguration, featureEnvironments, featureConfigurationOptions, featureEnvironmentsOptions, }) => {
contextName = defaultContextName(contextName);
if (modulesByContextName[contextName] === undefined) {
modulesByContextName[contextName] = getSharedModule(contextName);
}
if (moduleSettings[contextName] === undefined) {
moduleSettings[contextName] = {};
}
if (featureConfiguration) {
if (featuresConfigurationByContextName[contextName] === undefined) {
featuresConfigurationByContextName[contextName] = [];
}
if (nestModuleMetadata.featureConfigurationModel) {
const obj = await (0, utils_1.configTransform)({
model: nestModuleMetadata.featureConfigurationModel,
data: featureConfiguration,
rootOptions: {
...featureConfigurationOptions,
...getRootConfigurationValidationOptions({ nestModuleMetadata, contextName }),
},
});
if (moduleSettings[contextName].featureModuleConfigurations === undefined) {
moduleSettings[contextName].featureModuleConfigurations = {};
}
if (moduleSettings[contextName].featureModuleConfigurations &&
moduleSettings[contextName].featureModuleConfigurations[featureModuleName] === undefined) {
moduleSettings[contextName].featureModuleConfigurations[featureModuleName] = [];
}
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
moduleSettings[contextName].featureModuleConfigurations[featureModuleName].push(obj.info);
featuresConfigurationByContextName[contextName].push({
featureModuleName,
featureConfiguration: obj.data,
});
featureConfiguration = obj.data;
}
else {
featuresConfigurationByContextName[contextName].push({ featureModuleName, featureConfiguration });
}
}
if (featuresEnvironmentsByContextName[contextName] === undefined) {
featuresEnvironmentsByContextName[contextName] = [];
}
if (nestModuleMetadata.featureEnvironmentsModel) {
if (featureEnvironments === undefined) {
featureEnvironments = {};
}
const obj = await (0, utils_2.envTransform)({
model: nestModuleMetadata.featureEnvironmentsModel,
data: featureEnvironments,
rootOptions: {
...featureEnvironmentsOptions,
...getRootEnvironmentsValidationOptions({
nestModuleMetadata,
contextName: defaultContextName() !== contextName ? `${contextName}_${featureModuleName}` : featureModuleName,
}),
},
});
if (moduleSettings[contextName].featureModuleEnvironments === undefined) {
moduleSettings[contextName].featureModuleEnvironments = {};
}
if (moduleSettings[contextName].featureModuleEnvironments &&
moduleSettings[contextName].featureModuleEnvironments[featureModuleName] === undefined) {
moduleSettings[contextName].featureModuleEnvironments[featureModuleName] = [];
}
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
moduleSettings[contextName].featureModuleEnvironments[featureModuleName].push(obj.info);
featuresEnvironmentsByContextName[contextName].push({
featureModuleName,
featureEnvironments: obj.data,
});
featureEnvironments = obj.data;
}
return { contextName, module: modulesByContextName[contextName], featureConfiguration, featureEnvironments };
};
let InternalNestModule = InternalNestModule_1 = class InternalNestModule {
static [forFeatureAsyncMethodName](asyncModuleOptions) {
if (!asyncModuleOptions) {
asyncModuleOptions = {};
}
if (nestModuleMetadata.wrapForFeatureAsync) {
const { asyncModuleOptions: newAsyncModuleOptions, module: wrapForFeatureAsyncModule } = nestModuleMetadata.wrapForFeatureAsync(asyncModuleOptions);
if (wrapForFeatureAsyncModule) {
return wrapForFeatureAsyncModule;
}
if (asyncModuleOptions && newAsyncModuleOptions) {
Object.assign(asyncModuleOptions, newAsyncModuleOptions);
}
}
const { featureConfiguration, featureEnvironments } = asyncModuleOptions || {};
let { featureConfigurationOptions, featureEnvironmentsOptions } = asyncModuleOptions || {};
const contextName = defaultContextName(asyncModuleOptions?.contextName);
if (featureConfigurationOptions === undefined) {
featureConfigurationOptions = {};
}
if (featureEnvironmentsOptions === undefined) {
featureEnvironmentsOptions = {};
}
async function getModule() {
// console.log('getModule:feature', nestModuleMetadata.moduleName);
const { module: settingsModule } = getOrCreateSettingsModule(contextName);
const { module: featureModule } = await getOrCreateFeatureModule({
contextName,
featureModuleName: asyncModuleOptions.featureModuleName,
featureConfiguration,
featureEnvironments,
featureConfigurationOptions,
featureEnvironmentsOptions,
});
const importsArr = asyncModuleOptions?.imports === undefined || Array.isArray(asyncModuleOptions.imports)
? asyncModuleOptions?.imports
: asyncModuleOptions.imports({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions: { configurationOptions: featureConfigurationOptions },
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions: { environmentsOptions: featureEnvironmentsOptions },
contextName,
}),
});
const imports = (nestModuleMetadata.imports === undefined ? [] : importsArr) || [];
const exportsArr = nestModuleMetadata.exports === undefined || Array.isArray(nestModuleMetadata.exports)
? nestModuleMetadata.exports
: nestModuleMetadata.exports({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
contextName,
}),
});
const exports = (nestModuleMetadata.exports === undefined ? [] : exportsArr) || [];
return {
module: (0, name_it_class_1.nameItClass)(nestModuleMetadata.moduleName, InternalNestModule_1),
providers: [createUniqProvider()],
imports: [settingsModule, featureModule, ...imports],
exports: [...exports, settingsModule, featureModule],
};
}
// hack for disable auto resolving promise in nodejs
// console.log('getModule:feature:before', nestModuleMetadata.moduleName);
const result = Promise.resolve().then(() => getModule());
// console.log('getModule:feature:after', nestModuleMetadata.moduleName);
const nestModuleMetadataMethods = getWrapModuleMetadataMethods();
Object.assign(result, {
getNestModuleMetadata: () => {
return {
...nestModuleMetadata,
project: nestModuleMetadata.project || {},
...nestModuleMetadataMethods
.map((method) => ({ [method]: undefined }))
.reduce((all, cur) => ({ ...all, ...cur }), {}),
};
},
moduleSettings,
// need to set global options for configurations and environments
// todo: try remove it
pathNestModuleMetadata: (newNestModuleMetadata) => {
const keys = Object.keys(newNestModuleMetadata);
const globalConfigurationOptions = newNestModuleMetadata.globalConfigurationOptions;
const globalEnvironmentsOptions = newNestModuleMetadata.globalEnvironmentsOptions;
const logger = newNestModuleMetadata.logger;
if (featureConfigurationOptions && nestModuleMetadata?.globalConfigurationOptions) {
Object.assign(featureConfigurationOptions, nestModuleMetadata.globalConfigurationOptions || {});
}
if (featureEnvironmentsOptions && nestModuleMetadata?.globalEnvironmentsOptions) {
Object.assign(featureEnvironmentsOptions, nestModuleMetadata.globalEnvironmentsOptions || {});
}
for (const key of keys) {
if (newNestModuleMetadata[key].constructor !== Object) {
Object.setPrototypeOf(nestModuleMetadata[key], newNestModuleMetadata[key]);
}
if (nestModuleMetadata[key]) {
Object.assign(nestModuleMetadata[key], newNestModuleMetadata[key] || {});
}
else {
nestModuleMetadata[key] = newNestModuleMetadata[key];
}
}
const imports = nestModuleMetadata?.imports || [];
if (Array.isArray(imports)) {
for (const imp of imports) {
if ('pathNestModuleMetadata' in imp && imp.pathNestModuleMetadata) {
imp.pathNestModuleMetadata({
...(newNestModuleMetadata.project ? { project: newNestModuleMetadata.project } : {}),
...(globalConfigurationOptions ? { globalConfigurationOptions } : {}),
...(globalEnvironmentsOptions ? { globalEnvironmentsOptions } : {}),
...(logger ? { logger } : {}),
});
}
}
}
const sharedImports = nestModuleMetadata?.sharedImports || [];
if (Array.isArray(sharedImports)) {
for (const imp of sharedImports) {
if ('pathNestModuleMetadata' in imp && imp.pathNestModuleMetadata) {
imp.pathNestModuleMetadata({
...(newNestModuleMetadata.project ? { project: newNestModuleMetadata.project } : {}),
...(globalConfigurationOptions ? { globalConfigurationOptions } : {}),
...(globalEnvironmentsOptions ? { globalEnvironmentsOptions } : {}),
...(logger ? { logger } : {}),
});
}
}
}
},
});
forFeatureModules.push(result);
return result;
}
static [forFeatureMethodName](moduleOptions) {
return this[forFeatureAsyncMethodName]({
...(moduleOptions || {}),
});
}
static [forRootMethodName](moduleOptions) {
return this[forRootAsyncMethodName]({
...(moduleOptions || {}),
});
}
static [forRootAsyncMethodName](asyncModuleOptions) {
if (!asyncModuleOptions) {
asyncModuleOptions = {};
}
if (nestModuleMetadata.wrapForRootAsync) {
const { asyncModuleOptions: newAsyncModuleOptions, module: wrapForRootAsync } = nestModuleMetadata.wrapForRootAsync(asyncModuleOptions);
if (wrapForRootAsync) {
return wrapForRootAsync;
}
if (asyncModuleOptions && newAsyncModuleOptions) {
Object.assign(asyncModuleOptions, newAsyncModuleOptions);
}
}
const contextName = defaultContextName(asyncModuleOptions?.contextName);
let staticConfiguration;
let staticEnvironments;
async function loadStaticSettingsForInfo() {
if (moduleSettings[contextName] === undefined) {
moduleSettings[contextName] = {};
}
// need for documentation
if (moduleSettings[contextName].featureConfiguration === undefined) {
if (nestModuleMetadata.featureConfigurationModel) {
const obj = await (0, utils_1.configTransform)({
model: nestModuleMetadata.featureConfigurationModel,
data: {},
rootOptions: {
...getRootConfigurationValidationOptions({ nestModuleMetadata, asyncModuleOptions, contextName }),
skipValidation: true,
},
});
moduleSettings[contextName].featureConfiguration = obj.info;
}
}
if (moduleSettings[contextName].featureEnvironments === undefined) {
if (nestModuleMetadata.featureEnvironmentsModel) {
const obj = await (0, utils_2.envTransform)({
model: nestModuleMetadata.featureEnvironmentsModel,
data: {},
rootOptions: {
...getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName: defaultContextName() !== contextName ? `${contextName}_FEATURE_MODULE_NAME` : 'FEATURE_MODULE_NAME',
}),
skipValidation: true,
demoMode: true,
},
});
moduleSettings[contextName].featureEnvironments = obj.info;
}
}
if (moduleSettings[contextName].configuration === undefined) {
if (nestModuleMetadata.configurationModel) {
const obj = await (0, utils_1.configTransform)({
model: nestModuleMetadata.configurationModel,
data: {},
rootOptions: {
...getRootConfigurationValidationOptions({ nestModuleMetadata, asyncModuleOptions, contextName }),
skipValidation: true,
},
});
moduleSettings[contextName].configuration = obj.info;
}
}
if (moduleSettings[contextName].staticConfiguration === undefined) {
if (nestModuleMetadata.staticConfigurationModel) {
const obj = await (0, utils_1.configTransform)({
model: nestModuleMetadata.staticConfigurationModel,
data: {},
rootOptions: {
...getRootConfigurationValidationOptions({ nestModuleMetadata, asyncModuleOptions, contextName }),
skipValidation: true,
},
});
moduleSettings[contextName].staticConfiguration = obj.info;
}
}
if (moduleSettings[contextName].environments === undefined) {
if (nestModuleMetadata.environmentsModel) {
const obj = await (0, utils_2.envTransform)({
model: nestModuleMetadata.environmentsModel,
data: {},
rootOptions: {
...getRootEnvironmentsValidationOptions({ nestModuleMetadata, asyncModuleOptions, contextName }),
skipValidation: true,
demoMode: true,
},
});
moduleSettings[contextName].environments = obj.info;
}
}
if (moduleSettings[contextName].staticEnvironments === undefined) {
if (nestModuleMetadata.staticEnvironmentsModel) {
const obj = await (0, utils_2.envTransform)({
model: nestModuleMetadata.staticEnvironmentsModel,
data: {},
rootOptions: {
...getRootEnvironmentsValidationOptions({ nestModuleMetadata, asyncModuleOptions, contextName }),
skipValidation: true,
demoMode: true,
},
});
moduleSettings[contextName].staticEnvironments = obj.info;
}
}
}
const loadStaticSettings = async () => {
await loadStaticSettingsForInfo();
if (moduleSettings[contextName] === undefined) {
moduleSettings[contextName] = {};
}
if (staticConfiguration === undefined) {
staticConfiguration = asyncModuleOptions?.staticConfiguration;
if (nestModuleMetadata.staticConfigurationModel) {
const obj = await (0, utils_1.configTransform)({
model: nestModuleMetadata.staticConfigurationModel,
data: staticConfiguration || {},
rootOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
});
moduleSettings[contextName].staticConfiguration = obj.info;
staticConfiguration = obj.data;
}
}
if (staticEnvironments === undefined) {
staticEnvironments = asyncModuleOptions?.staticEnvironments;
if (nestModuleMetadata.staticEnvironmentsModel) {
const obj = await (0, utils_2.envTransform)({
model: nestModuleMetadata.staticEnvironmentsModel,
rootOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
data: staticEnvironments || {},
});
moduleSettings[contextName].staticEnvironments = obj.info;
staticEnvironments = obj.data;
}
}
};
async function getModule() {
// console.log('getModule:root', nestModuleMetadata.moduleName);
await loadStaticSettings();
const asyncConfigurationProviderLoaderToken = getAsyncConfigurationToken(contextName);
let asyncOptionsProviderLoader = {
provide: asyncConfigurationProviderLoaderToken,
useValue: {},
};
let OnModuleDestroyService = class OnModuleDestroyService {
constructor() {
this.unsubscribe$ = new rxjs_1.Subject();
}
onModuleDestroy() {
this.unsubscribe$.next(true);
this.unsubscribe$.complete();
}
};
OnModuleDestroyService = tslib_1.__decorate([
(0, common_1.Injectable)()
], OnModuleDestroyService);
if (asyncModuleOptions) {
if ('configurationClass' in asyncModuleOptions) {
asyncOptionsProviderLoader = {
provide: asyncConfigurationProviderLoaderToken,
useClass: asyncModuleOptions.configurationClass,
};
}
if ('configurationExisting' in asyncModuleOptions) {
asyncOptionsProviderLoader = {
provide: asyncConfigurationProviderLoaderToken,
useExisting: asyncModuleOptions.configurationExisting,
};
}
if ('configurationFactory' in asyncModuleOptions) {
asyncOptionsProviderLoader = {
provide: asyncConfigurationProviderLoaderToken,
useFactory: asyncModuleOptions.configurationFactory,
inject: 'inject' in asyncModuleOptions
? asyncModuleOptions.inject
: [],
};
}
if ('configurationStream' in asyncModuleOptions) {
asyncOptionsProviderLoader = {
provide: asyncConfigurationProviderLoaderToken,
useFactory: (...args) => {
if (asyncModuleOptions?.configurationStream) {
return asyncModuleOptions.configurationStream(args);
}
return undefined;
},
inject: 'inject' in asyncModuleOptions
? [...asyncModuleOptions.inject]
: [],
};
}
if ('configuration' in asyncModuleOptions) {
asyncOptionsProviderLoader = {
provide: asyncConfigurationProviderLoaderToken,
useValue: asyncModuleOptions.configuration || {},
};
}
}
// console.log({ n: nestModuleMetadata.moduleName, p: nestModuleMetadata.project });
const { module: settingsModule } = getOrCreateSettingsModule(contextName);
const { module: featureModule, featureConfiguration, featureEnvironments, } = getFeatureModule({ contextName, staticConfiguration, staticEnvironments });
const importsArr = nestModuleMetadata.imports === undefined || Array.isArray(nestModuleMetadata.imports)
? nestModuleMetadata.imports
: nestModuleMetadata.imports({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
staticConfiguration,
staticEnvironments,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
});
const imports = (nestModuleMetadata.imports === undefined ? [] : importsArr) || [];
const asyncImportsArr = asyncModuleOptions?.imports === undefined || Array.isArray(asyncModuleOptions.imports)
? asyncModuleOptions?.imports
: asyncModuleOptions.imports({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
staticConfiguration,
staticEnvironments,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
});
const asyncImports = (asyncModuleOptions?.imports === undefined ? [] : asyncImportsArr) || [];
const controllersArr = nestModuleMetadata.controllers === undefined || Array.isArray(nestModuleMetadata.controllers)
? nestModuleMetadata.controllers
: nestModuleMetadata.controllers({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
staticConfiguration,
staticEnvironments,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
});
const controllers = (nestModuleMetadata.controllers === undefined ? [] : controllersArr) || [];
const providersArr = nestModuleMetadata.providers === undefined || Array.isArray(nestModuleMetadata.providers)
? nestModuleMetadata.providers
: nestModuleMetadata.providers({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
staticConfiguration,
staticEnvironments,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
globalEnvironmentsOptions: getRootEnvironmentsValidationOptions({
nestModuleMetadata,
asyncModuleOptions,
contextName,
}),
});
const providers = (nestModuleMetadata.providers === undefined ? [] : providersArr) || [];
const exportsArr = nestModuleMetadata.exports === undefined || Array.isArray(nestModuleMetadata.exports)
? nestModuleMetadata.exports
: nestModuleMetadata.exports({
project: nestModuleMetadata.project,
contextName,
settingsModule,
featureModule,
staticConfiguration,
staticEnvironments,
featureConfiguration,
featureEnvironments,
globalConfigurationOptions: getRootConfigurationValidationOptions({
nestModuleMetadata,
asyncModuleOptions,