@lenne.tech/nest-server 8.6.27 → 8.6.28

package/src/core/common/services/config.service.ts

@@ -1,35 +1,401 @@
 import * as _ from 'lodash';
+import { cloneDeep } from 'lodash';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { merge } from '../helpers/config.helper';
+import { clone, deepFreeze } from '../helpers/input.helper';
 import { IServerOptions } from '../interfaces/server-options.interface';
 
 /**
- * Config service
+ * Config service can be used as provider (after initialization in CoreModule.forRoot)
+ *
+ * Note:
+ *
+ * Direct access to the global configuration is not intended, since all objects in JavaScript interact by reference
+ * it can come to unintentional changes. Two protected properties are available for access `config` and
+ * `configFastButReadOnly`, as well as several methods that use these properties.
+ *
+ * The return value of `configFastButReadOnly` is a cached deep frozen object to speed up access and to avoid unwanted
+ * side effects (like accidentally changing the global configuration). However, this results in the object and all its
+ * contents being read-only. Attempts to change the configuration will result in the
+ * `TypeError: Cannot assign to read only property ...` If this error occurs during further processing of the
+ * configuration, `config` should be used instead of `configFastButReadOnly`. The access via `config` is substantially
+ * slower, but offers the advantage that the clone can be processed further (also without changing the
+ * global configuration).
+ *
+ * `configFastButReadOnly` => fast read only copy of global configuration
+ *                            (return value of getFastButReadOnly, observableFastButReadOnly and promiseFastButReadOnly)
+ *
+ * `config` => slower read and writeable copy of global configuration
+ *             (return value of get, observable and promise)
  */
 export class ConfigService {
+  // ===================================================================================================================
+  // Properties
+  // ===================================================================================================================
+
   /**
-   * Configuration on startup
+   * BehaviorSubject for config
    */
-  protected readonly _config: { [key: string]: any } & Partial<IServerOptions>;
+  protected static _configSubject$: BehaviorSubject<{ [key: string]: any } & Partial<IServerOptions>> =
+    new BehaviorSubject(undefined);
 
   /**
-   * Create config service
+   * BehaviorSubject for frozen config
    */
-  constructor(config: { [key: string]: any } & Partial<IServerOptions>) {
-    this._config = config || {};
+  protected static _frozenConfigSubject$: BehaviorSubject<{ [key: string]: any } & Partial<IServerOptions>> =
+    new BehaviorSubject(undefined);
+
+  /**
+   * Singleton instance of ConfigService
+   */
+  protected static _instance: ConfigService;
+
+  // ===================================================================================================================
+  // Constructor
+  // ===================================================================================================================
+
+  /**
+   * Create config service or return singleton instance if exists
+   */
+  constructor(
+    configObject?: { [key: string]: any } & Partial<IServerOptions>,
+    options?: { reInit?: boolean; warn?: boolean }
+  ) {
+    const config = {
+      reInit: false,
+      warn: true,
+      ...options,
+    };
+
+    // Check initialization status
+    const isInitialized = ConfigService.isInitialized;
+
+    // Init subject handling
+    if (!isInitialized) {
+      ConfigService._configSubject$.subscribe((config) => {
+        ConfigService._frozenConfigSubject$.next(deepFreeze(config));
+      });
+    }
+
+    // Set config before setting instance
+    if (typeof configObject === 'object') {
+      isInitialized
+        ? ConfigService.mergeConfig(configObject, { ...config, ...{ init: false } })
+        : ConfigService.setConfig(configObject, { ...config, ...{ init: false } });
+    }
+
+    // Set instance if not yet initialized
+    if (!isInitialized) {
+      ConfigService._instance = this;
+    }
+
+    // Return instance
+    return ConfigService._instance;
   }
 
+  // ===================================================================================================================
+  // Getter / Queries
+  // ===================================================================================================================
+
   /**
-   * Get config (deep cloned to avoid unwanted side effects)
+   * Get readable and writable deep-cloned configuration
    */
   get config() {
-    return _.cloneDeep(this._config);
+    return ConfigService.config;
   }
 
   /**
-   * Get data from config (deep cloned to avoid unwanted side effects)
-   * @param key Property name of config object, which is to be returned
-   * @param defaultValue Default value which is to be returned if property doesn't exist
+   * Get readable and writable deep-cloned configuration
+   */
+  static get config() {
+    return clone(ConfigService._configSubject$.getValue(), { circles: false });
+  }
+
+  /**
+   * Get faster but read-only deep-frozen configuration
+   */
+  get configFastButReadOnly() {
+    return ConfigService.configFastButReadOnly;
+  }
+
+  /**
+   * Get faster but read-only deep-frozen configuration
+   */
+  static get configFastButReadOnly() {
+    return ConfigService._frozenConfigSubject$.getValue();
+  }
+
+  /**
+   * Get readable and writable deep-cloned property from configuration
    */
   get(key: string, defaultValue: any = undefined) {
-    return _.cloneDeep(_.get(this._config, key, defaultValue));
+    return ConfigService.get(key, defaultValue);
+  }
+
+  /**
+   * Get readable and writable deep-cloned property from configuration
+   */
+  static get(key: string, defaultValue: any = undefined) {
+    return clone(_.get(ConfigService._configSubject$.getValue(), key, defaultValue), { circles: false });
+  }
+
+  /**
+   * Get faster but read-ony deep-frozen property from configuration
+   */
+  getFastButReadOnly(key: string, defaultValue: any = undefined) {
+    return ConfigService.getFastButReadOnly(key, defaultValue);
+  }
+
+  /**
+   * Get faster but read-ony deep-frozen property from configuration
+   */
+  static getFastButReadOnly(key: string, defaultValue: any = undefined) {
+    return _.get(ConfigService._frozenConfigSubject$.getValue(), key, defaultValue);
+  }
+
+  /**
+   * Whether the ConfigService is initialized
+   */
+  get isInitialized() {
+    return ConfigService.isInitialized;
+  }
+
+  /**
+   * Whether the ConfigService is initialized
+   */
+  static get isInitialized() {
+    return !!ConfigService._instance;
+  }
+
+  /**
+   * Get observable for readable and writable deep-cloned configuration
+   */
+  get observableClone() {
+    return ConfigService.observable;
+  }
+
+  /**
+   * Get observable for readable and writable deep-cloned configuration
+   */
+  static get observable() {
+    return ConfigService._configSubject$.asObservable().pipe(
+      filter((config) => !config),
+      map((config) => clone(config, { circles: false }))
+    );
+  }
+
+  /**
+   * Get observable for faster but read-only deep-frozen configuration
+   */
+  get observableFastButReadOnly() {
+    return ConfigService.observableFastButReadOnly;
+  }
+
+  /**
+   * Get observable for faster but read-only deep-frozen configuration
+   */
+  static get observableFastButReadOnly() {
+    return ConfigService._frozenConfigSubject$.asObservable().pipe(filter((config) => !config));
+  }
+
+  /**
+   * Get promise of first readable and writable deep-cloned configuration
+   */
+  get promise() {
+    return ConfigService.promise;
+  }
+
+  /**
+   * Get promise of first readable and writable deep-cloned configuration
+   */
+  static get promise() {
+    return firstValueFrom(ConfigService.observable);
+  }
+
+  /**
+   * Get promise of first faster but read-ony deep-frozen configuration
+   */
+  get promiseFastButReadOnly() {
+    return ConfigService.promiseFastButReadOnly;
+  }
+
+  /**
+   * Get promise of first faster but read-ony deep-frozen configuration
+   */
+  static get promiseFastButReadOnly() {
+    return firstValueFrom(ConfigService.observableFastButReadOnly);
+  }
+
+  // ===================================================================================================================
+  // Setter / Mutations
+  // ===================================================================================================================
+
+  /**
+   * Merge config and set in ConfigService
+   */
+  mergeConfig(configData: { [key: string]: any } & Partial<IServerOptions>, options?: { warn?: boolean }) {
+    return ConfigService.mergeConfig(configData, options);
+  }
+
+  /**
+   * Merge config and set in ConfigService
+   */
+  static mergeConfig(
+    configData: { [key: string]: any } & Partial<IServerOptions>,
+    options?: { init?: boolean; warn?: boolean }
+  ) {
+    const config = {
+      init: true,
+      warn: false,
+      ...options,
+    };
+
+    // Get initialization status
+    const isInitialized = ConfigService.isInitialized;
+
+    // Init config service instance, if not yet initialized
+    if (!isInitialized && config.init) {
+      new ConfigService();
+    }
+
+    // Merge config
+    const activity = isInitialized ? 'merged' : 'initialized';
+    const merged = merge(ConfigService._configSubject$.getValue() || {}, cloneDeep(configData));
+    ConfigService._configSubject$.next(merged);
+
+    // Warn if requested
+    if (config.warn) {
+      console.warn('ConfigService ' + activity, JSON.stringify(merged, null, 2));
+    }
+
+    // Return configuration
+    return ConfigService.config;
+  }
+
+  /**
+   * Merge config property and set in ConfigService
+   */
+  mergeProperty(key: string, value: any, options?: { warn?: boolean }) {
+    return ConfigService.mergeProperty(key, options);
+  }
+
+  /**
+   * Merge config property and set in ConfigService
+   */
+  static mergeProperty(key: string, value: any, options?: { warn?: boolean }) {
+    const config = {
+      warn: false,
+      ...options,
+    };
+
+    // Init config service instance, if not yet initialized
+    if (!ConfigService.isInitialized) {
+      new ConfigService();
+    }
+
+    // Merge property
+    const current = ConfigService._configSubject$.getValue() || {};
+    if (typeof value === 'object') {
+      current[key] = merge(current[key], cloneDeep(value));
+    } else {
+      current[key] = value;
+    }
+    ConfigService._configSubject$.next(current);
+
+    // Warn if requested
+    if (config.warn) {
+      console.warn('ConfigService ' + key + ':', JSON.stringify(current[key], null, 2));
+    }
+
+    // Return configuration
+    return ConfigService.config;
+  }
+
+  /**
+   * Set config in ConfigService
+   */
+  setConfig(
+    configData: { [key: string]: any } & Partial<IServerOptions>,
+    options?: { reInit?: boolean; warn?: boolean }
+  ) {
+    return ConfigService.setConfig(configData, options);
+  }
+
+  /**
+   * Set config in ConfigService
+   */
+  static setConfig(
+    configObject: { [key: string]: any } & Partial<IServerOptions>,
+    options?: { init?: boolean; reInit?: boolean; warn?: boolean }
+  ) {
+    const config = {
+      init: true,
+      reInit: true,
+      warn: false,
+      ...options,
+    };
+
+    // Check initialization
+    const firstInitialization = !ConfigService.isInitialized;
+
+    // Check for unintentional overwriting
+    if (!firstInitialization && !config.reInit) {
+      throw new Error(
+        'Unintentional overwriting of the configuration. ' +
+          'If overwriting is desired, please set `reInit` in setConfig of ConfigService to `true`.'
+      );
+    }
+
+    // Init config service instance, if not yet initialized
+    if (firstInitialization && config.init) {
+      new ConfigService();
+    }
+
+    // (Re)Init
+    if (firstInitialization || config.reInit) {
+      ConfigService._configSubject$.next(configObject || {});
+
+      // Warn if requested
+      if (config.warn && !firstInitialization) {
+        console.warn('ConfigService reinitialized', JSON.stringify(configObject, null, 2));
+      }
+    }
+
+    // Return configuration
+    return ConfigService.config;
+  }
+
+  /**
+   * Set config property in ConfigService
+   */
+  setProperty(key: string, value: any, options?: { warn?: boolean }) {
+    return ConfigService.setProperty(key, options);
+  }
+
+  /**
+   * Set config property in ConfigService
+   */
+  static setProperty(key: string, value: any, options?: { warn?: boolean }) {
+    const config = {
+      warn: false,
+      ...options,
+    };
+
+    // Init config service instance
+    if (!ConfigService.isInitialized) {
+      new ConfigService();
+    }
+
+    // Set property
+    const current = ConfigService._configSubject$.getValue() || {};
+    current[key] = value;
+    ConfigService._configSubject$.next(current);
+    if (config.warn) {
+      console.warn('ConfigService ' + key + ':', JSON.stringify(value, null, 2));
+    }
+
+    // Return config
+    return ConfigService.config;
   }
 }

package/src/core/common/services/email.service.ts

@@ -34,8 +34,8 @@ export class EmailService {
   ): Promise<any> {
     // Process config
     const { attachments, htmlTemplate, senderName, senderEmail, templateData, textTemplate } = {
-      senderEmail: this.configService.get('email.defaultSender.email'),
-      senderName: this.configService.get('email.defaultSender.name'),
+      senderEmail: this.configService.getFastButReadOnly('email.defaultSender.email'),
+      senderName: this.configService.getFastButReadOnly('email.defaultSender.name'),
       ...config,
     };
 

package/src/core/common/services/mailjet.service.ts

@@ -34,8 +34,8 @@ export class MailjetService {
   ) {
     // Process config
     const { senderName, senderEmail, templateData, attachments, sandbox } = {
-      senderEmail: this.configService.get('email.defaultSender.email'),
-      senderName: this.configService.get('email.defaultSender.name'),
+      senderEmail: this.configService.getFastButReadOnly('email.defaultSender.email'),
+      senderName: this.configService.getFastButReadOnly('email.defaultSender.name'),
       sandbox: false,
       attachments: null,
       templateData: null,
@@ -76,8 +76,8 @@ export class MailjetService {
     try {
       // Connect to mailjet
       connection = new Mailjet({
-        apiKey: this.configService.get('email.mailjet.api_key_public'),
-        apiSecret: this.configService.get('email.mailjet.api_key_private'),
+        apiKey: this.configService.getFastButReadOnly('email.mailjet.api_key_public'),
+        apiSecret: this.configService.getFastButReadOnly('email.mailjet.api_key_private'),
       });
     } catch (e) {
       throw new Error('Cannot connect to mailjet.');

package/src/core/common/services/template.service.ts

@@ -44,7 +44,7 @@ export class TemplateService {
 
       // Get template file
       fs.readFile(
-        join(this.configService.get('templates.path'), filePath) + '.ejs',
+        join(this.configService.getFastButReadOnly('templates.path'), filePath) + '.ejs',
         { encoding: 'utf8' },
         (err, data) => {
           if (err) {

package/src/core/modules/user/core-user.service.ts

@@ -3,10 +3,10 @@ import * as bcrypt from 'bcrypt';
 import * as crypto from 'crypto';
 import { sha256 } from 'js-sha256';
 import { Document, Model } from 'mongoose';
-import envConfig from '../../../config.env';
 import { merge } from '../../common/helpers/config.helper';
 import { assignPlain } from '../../common/helpers/input.helper';
 import { ServiceOptions } from '../../common/interfaces/service-options.interface';
+import { ConfigService } from '../../common/services/config.service';
 import { CrudService } from '../../common/services/crud.service';
 import { EmailService } from '../../common/services/email.service';
 import { CoreModelConstructor } from '../../common/types/core-model-constructor.type';
@@ -23,9 +23,10 @@ export abstract class CoreUserService<
   TUserCreateInput extends CoreUserCreateInput
 > extends CrudService<TUser> {
   protected constructor(
-    protected emailService: EmailService,
+    protected readonly emailService: EmailService,
     protected readonly mainDbModel: Model<TUser & Document>,
-    protected mainModelConstructor: CoreModelConstructor<TUser>
+    protected readonly mainModelConstructor: CoreModelConstructor<TUser>,
+    protected readonly configService?: ConfigService
   ) {
     super();
   }
@@ -132,7 +133,7 @@ export abstract class CoreUserService<
       async () => {
         // Check if the password was transmitted encrypted
         // If not, the password is encrypted to enable future encrypted and unencrypted transmissions
-        if (envConfig.sha256 && !/^[a-f0-9]{64}$/i.test(newPassword)) {
+        if (this.configService.configFastButReadOnly.sha256 && !/^[a-f0-9]{64}$/i.test(newPassword)) {
           newPassword = sha256(newPassword);
         }
 

package/src/server/common/services/cron-jobs.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { SchedulerRegistry } from '@nestjs/schedule';
-import envConfig from '../../../config.env';
+import { ConfigService } from '../../../core/common/services/config.service';
 import { CoreCronJobs } from '../../../core/common/services/core-cron-jobs.service';
 
 @Injectable()
@@ -12,8 +12,8 @@ export class CronJobs extends CoreCronJobs {
   /**
    * Init cron jobs
    */
-  constructor(protected schedulerRegistry: SchedulerRegistry) {
-    super(schedulerRegistry, envConfig.cronJobs, { log: true });
+  constructor(protected schedulerRegistry: SchedulerRegistry, protected configService: ConfigService) {
+    super(schedulerRegistry, configService.config.cronJobs, { log: true });
   }
 
   // ===================================================================================================================

package/src/server/modules/auth/auth.service.ts

@@ -2,11 +2,11 @@ import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import * as bcrypt from 'bcrypt';
 import { sha256 } from 'js-sha256';
-import envConfig from '../../../config.env';
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { prepareServiceOptions } from '../../../core/common/helpers/service.helper';
 import { ServiceOptions } from '../../../core/common/interfaces/service-options.interface';
+import { ConfigService } from '../../../core/common/services/config.service';
 import { EmailService } from '../../../core/common/services/email.service';
 import { JwtPayload } from '../../../core/modules/auth/interfaces/jwt-payload.interface';
 import { UserService } from '../user/user.service';
@@ -20,7 +20,8 @@ export class AuthService {
   constructor(
     protected readonly jwtService: JwtService,
     protected readonly emailService: EmailService,
-    protected readonly userService: UserService
+    protected readonly userService: UserService,
+    protected readonly configService: ConfigService
   ) {}
 
   /**
@@ -77,7 +78,10 @@ export class AuthService {
     // Send email
     await this.emailService.sendMail(user.email, 'Welcome', {
       htmlTemplate: 'welcome',
-      templateData: { name: user.username, link: envConfig.email.verificationLink + '/' + user.verificationToken },
+      templateData: {
+        name: user.username,
+        link: this.configService.configFastButReadOnly.email.verificationLink + '/' + user.verificationToken,
+      },
     });
 
     // Create JWT and return sign-in data

package/src/server/modules/user/user.service.ts

@@ -3,7 +3,6 @@ import { InjectModel } from '@nestjs/mongoose';
 import * as fs from 'fs';
 import { PubSub } from 'graphql-subscriptions';
 import { Model } from 'mongoose';
-import envConfig from '../../../config.env';
 import { ServiceOptions } from '../../../core/common/interfaces/service-options.interface';
 import { ConfigService } from '../../../core/common/services/config.service';
 import { EmailService } from '../../../core/common/services/email.service';
@@ -72,7 +71,10 @@ export class UserService extends CoreUserService<User, UserInput, UserCreateInpu
     // Send email
     await this.emailService.sendMail(user.email, 'Password reset', {
       htmlTemplate: 'password-reset',
-      templateData: { name: user.username, link: envConfig.email.passwordResetLink + '/' + user.passwordResetToken },
+      templateData: {
+        name: user.username,
+        link: this.configService.configFastButReadOnly.email.passwordResetLink + '/' + user.passwordResetToken,
+      },
     });
 
     // Return user
@@ -96,7 +98,7 @@ export class UserService extends CoreUserService<User, UserInput, UserCreateInpu
 
     // Remove old avatar image
     if (user.avatar) {
-      fs.unlink(envConfig.staticAssets.path + '/avatars/' + user.avatar, (err) => {
+      fs.unlink(this.configService.configFastButReadOnly.staticAssets.path + '/avatars/' + user.avatar, (err) => {
         if (err) {
           console.error(err);
         }

package/src/server/server.controller.ts

@@ -9,13 +9,13 @@ export class ServerController {
   @Render('index')
   root() {
     return {
-      env: this.configService.get('env'),
+      env: this.configService.getFastButReadOnly('env'),
     };
   }
 
   @Get('config')
   @Roles(RoleEnum.ADMIN)
   config() {
-    return this.configService.config;
+    return this.configService.configFastButReadOnly;
   }
 }