@lenne.tech/nest-server 10.0.2 → 10.0.4

package/src/core/modules/auth/core-auth.controller.ts

@@ -28,7 +28,7 @@ export class CoreAuthController {
     @CurrentUser() currentUser: ICoreAuthUser,
     @Tokens('token') token: string,
     @Res() res: ResponseType,
-    @Param('allDevices', ParseBoolPipe) allDevices?: boolean
+    @Param('allDevices', ParseBoolPipe) allDevices?: boolean,
   ): Promise<boolean> {
     const result = await this.authService.logout(token, { currentUser, allDevices });
     return this.processCookies(res, result);
@@ -42,7 +42,7 @@ export class CoreAuthController {
   async refreshToken(
     @CurrentUser() user: ICoreAuthUser,
     @Tokens('refreshToken') refreshToken: string,
-    @Res() res: ResponseType
+    @Res() res: ResponseType,
   ): Promise<CoreAuthModel> {
     const result = await this.authService.refreshTokens(user, refreshToken);
     return this.processCookies(res, result);

package/src/core/modules/auth/core-auth.module.ts

@@ -2,13 +2,13 @@ import { DynamicModule, ForwardReference, Module, Provider, Type } from '@nestjs
 import { APP_GUARD } from '@nestjs/core';
 import { JwtModule, JwtModuleOptions } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
+import { PubSub } from 'graphql-subscriptions';
 import { AuthGuardStrategy } from './auth-guard-strategy.enum';
 import { RolesGuard } from './guards/roles.guard';
 import { JwtRefreshStrategy } from './strategies/jwt-refresh.strategy';
 import { JwtStrategy } from './strategies/jwt.strategy';
 import { CoreAuthUserService } from './services/core-auth-user.service';
 import { CoreAuthService } from './services/core-auth.service';
-import { PubSub } from 'graphql-subscriptions';
 
 /**
  * CoreAuthModule to handle user authentication and enables Roles
@@ -28,7 +28,7 @@ export class CoreAuthModule {
       jwtRefreshStrategy?: Type<JwtRefreshStrategy>;
       imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
       providers?: Provider[];
-    }
+    },
   ): DynamicModule {
     // Process imports
     let imports: any[] = [
@@ -75,8 +75,8 @@ export class CoreAuthModule {
     // Return CoreAuthModule
     return {
       module: CoreAuthModule,
-      imports: imports,
-      providers: providers,
+      imports,
+      providers,
       exports: [CoreAuthService, JwtModule, JwtStrategy, JwtRefreshStrategy, PassportModule, UserModule],
     };
   }

package/src/core/modules/auth/core-auth.resolver.ts

@@ -17,7 +17,7 @@ import { Tokens } from './tokens.decorator';
 /**
  * Authentication resolver for the sign in
  */
-@Resolver((of) => CoreAuthModel, { isAbstract: true })
+@Resolver(of => CoreAuthModel, { isAbstract: true })
 export class CoreAuthResolver {
   /**
    * Import services
@@ -32,12 +32,12 @@ export class CoreAuthResolver {
    * Logout user (from specific device)
    */
   @UseGuards(AuthGuard(AuthGuardStrategy.JWT))
-  @Mutation((returns) => Boolean, { description: 'Logout user (from specific device)' })
+  @Mutation(returns => Boolean, { description: 'Logout user (from specific device)' })
   async logout(
     @CurrentUser() currentUser: ICoreAuthUser,
     @Context() ctx: { res: ResponseType },
     @Tokens('token') token: string,
-    @Args('allDevices', { nullable: true }) allDevices?: boolean
+    @Args('allDevices', { nullable: true }) allDevices?: boolean,
   ): Promise<boolean> {
     const result = await this.authService.logout(token, { currentUser, allDevices });
     return this.processCookies(ctx, result);
@@ -47,11 +47,11 @@ export class CoreAuthResolver {
    * Refresh token (for specific device)
    */
   @UseGuards(AuthGuard(AuthGuardStrategy.JWT_REFRESH))
-  @Mutation((returns) => CoreAuthModel, { description: 'Refresh tokens (for specific device)' })
+  @Mutation(returns => CoreAuthModel, { description: 'Refresh tokens (for specific device)' })
   async refreshToken(
     @CurrentUser() user: ICoreAuthUser,
     @Tokens('refreshToken') refreshToken: string,
-    @Context() ctx: { res: ResponseType }
+    @Context() ctx: { res: ResponseType },
   ): Promise<CoreAuthModel> {
     const result = await this.authService.refreshTokens(user, refreshToken);
     return this.processCookies(ctx, result);
@@ -60,13 +60,13 @@ export class CoreAuthResolver {
   /**
    * Sign in user via email and password (on specific device)
    */
-  @Mutation((returns) => CoreAuthModel, {
+  @Mutation(returns => CoreAuthModel, {
     description: 'Sign in user via email and password and get JWT tokens (for specific device)',
   })
   async signIn(
     @GraphQLServiceOptions({ gqlPath: 'signIn.user' }) serviceOptions: ServiceOptions,
     @Context() ctx: { res: ResponseType },
-    @Args('input') input: CoreAuthSignInInput
+    @Args('input') input: CoreAuthSignInInput,
   ): Promise<CoreAuthModel> {
     const result = await this.authService.signIn(input, serviceOptions);
     return this.processCookies(ctx, result);
@@ -75,11 +75,11 @@ export class CoreAuthResolver {
   /**
    * Register a new user account (on specific device)
    */
-  @Mutation((returns) => CoreAuthModel, { description: 'Register a new user account (on specific device)' })
+  @Mutation(returns => CoreAuthModel, { description: 'Register a new user account (on specific device)' })
   async signUp(
     @GraphQLServiceOptions({ gqlPath: 'signUp.user' }) serviceOptions: ServiceOptions,
     @Context() ctx: { res: ResponseType },
-    @Args('input') input: CoreAuthSignUpInput
+    @Args('input') input: CoreAuthSignUpInput,
   ): Promise<CoreAuthModel> {
     const result = await this.authService.signUp(input, serviceOptions);
     return this.processCookies(ctx, result);

package/src/core/modules/auth/guards/auth.guard.ts

@@ -1,4 +1,4 @@
-import { CanActivate, ExecutionContext, Logger, mixin, Optional } from '@nestjs/common';
+import { CanActivate, ExecutionContext, Logger, Optional, mixin } from '@nestjs/common';
 import { GqlExecutionContext } from '@nestjs/graphql';
 import { AuthModuleOptions, Type } from '@nestjs/passport';
 import { defaultOptions } from '@nestjs/passport/dist/options';
@@ -12,9 +12,9 @@ import { InvalidTokenException } from '../exceptions/invalid-token.exception';
 /**
  * Missing strategy error
  */
-const NO_STRATEGY_ERROR =
-  'In order to use "defaultStrategy", please, ensure to import PassportModule in each ' +
-  "place where AuthGuard() is being used. Otherwise, passport won't work correctly.";
+const NO_STRATEGY_ERROR
+  = 'In order to use "defaultStrategy", please, ensure to import PassportModule in each '
+  + 'place where AuthGuard() is being used. Otherwise, passport won\'t work correctly.';
 
 /**
  * Interface for auth guard
@@ -37,7 +37,7 @@ const createPassportContext = (request, response) => (type, options, callback: (
       } catch (err) {
         reject(err);
       }
-    })(request, response, (err) => (err ? reject(err) : resolve))
+    })(request, response, err => (err ? reject(err) : resolve)),
   );
 
 /**
@@ -73,7 +73,7 @@ function createAuthGuard(type?: string): Type<CanActivate> {
       const request = this.getRequest(context);
       const passportFn = createPassportContext(request, response);
       const user = await passportFn(type || this.options.defaultStrategy, options, (err, currentUser, info) =>
-        this.handleRequest(err, currentUser, info, context)
+        this.handleRequest(err, currentUser, info, context),
       );
       request[options.property || defaultOptions.property] = user;
       return true;
@@ -100,12 +100,13 @@ function createAuthGuard(type?: string): Type<CanActivate> {
      */
     async logIn<TRequest extends { logIn: (...params) => any } = any>(request: TRequest) {
       const user = request[this.options.property || defaultOptions.property];
-      await new Promise<void>((resolve, reject) => request.logIn(user, (err) => (err ? reject(err) : resolve())));
+      await new Promise<void>((resolve, reject) => request.logIn(user, err => (err ? reject(err) : resolve())));
     }
 
     /**
      * Process request
      */
+    // eslint-disable-next-line unused-imports/no-unused-vars
     handleRequest(err, user, info, context): TUser {
       if (err) {
         throw new InvalidTokenException();

package/src/core/modules/auth/guards/roles.guard.ts

@@ -41,7 +41,7 @@ export class RolesGuard extends AuthGuard(AuthGuardStrategy.JWT) {
     }
 
     // Check roles
-    if (!roles || !roles.some((value) => !!value)) {
+    if (!roles || !roles.some(value => !!value)) {
       return user;
     }
 

package/src/core/modules/auth/services/core-auth.service.ts

@@ -1,7 +1,7 @@
+import { randomUUID } from 'crypto';
 import { BadRequestException, Injectable, UnauthorizedException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import bcrypt = require('bcrypt');
-import { randomUUID } from 'crypto';
 import { sha256 } from 'js-sha256';
 import { getStringIds } from '../../../common/helpers/db.helper';
 import { prepareServiceOptions } from '../../../common/helpers/service.helper';
@@ -25,7 +25,7 @@ export class CoreAuthService {
   constructor(
     protected readonly userService: CoreAuthUserService,
     protected readonly jwtService: JwtService,
-    protected readonly configService: ConfigService
+    protected readonly configService: ConfigService,
   ) {}
 
   /**
@@ -40,7 +40,7 @@ export class CoreAuthService {
    */
   async logout(
     tokenOrRefreshToken: string,
-    serviceOptions: ServiceOptions & { allDevices?: boolean }
+    serviceOptions: ServiceOptions & { allDevices?: boolean },
   ): Promise<boolean> {
     // Check authentication
     const user = serviceOptions.currentUser;
@@ -162,7 +162,7 @@ export class CoreAuthService {
   protected async getResult(
     user: ICoreAuthUser,
     data?: { [key: string]: any; deviceId?: string },
-    currentRefreshToken?: string
+    currentRefreshToken?: string,
   ) {
     // Create new tokens
     const tokens = await this.createTokens(user.id, data);
@@ -186,10 +186,10 @@ export class CoreAuthService {
       path += '.refresh';
     }
     return (
-      this.configService.getFastButReadOnly(path + '.signInOptions.secret') ||
-      this.configService.getFastButReadOnly(path + '.signInOptions.secretOrPrivateKey') ||
-      this.configService.getFastButReadOnly(path + '.secret') ||
-      this.configService.getFastButReadOnly(path + '.secretOrPrivateKey')
+      this.configService.getFastButReadOnly(`${path}.signInOptions.secret`)
+      || this.configService.getFastButReadOnly(`${path}.signInOptions.secretOrPrivateKey`)
+      || this.configService.getFastButReadOnly(`${path}.secret`)
+      || this.configService.getFastButReadOnly(`${path}.secretOrPrivateKey`)
     );
   }
 
@@ -226,7 +226,7 @@ export class CoreAuthService {
     user: ICoreAuthUser,
     currentRefreshToken: string,
     newRefreshToken: string,
-    data?: Record<string, any>
+    data?: Record<string, any>,
   ): Promise<string> {
     // Check if the update of the update token is allowed
     let deviceId: string;

package/src/core/modules/auth/strategies/jwt-refresh.strategy.ts

@@ -1,6 +1,6 @@
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
-import { Request as RequestType, Request } from 'express';
+import { Request, Request as RequestType } from 'express';
 import { ExtractJwt, Strategy } from 'passport-jwt';
 import { ConfigService } from '../../../common/services/config.service';
 import { AuthGuardStrategy } from '../auth-guard-strategy.enum';

package/src/core/modules/auth/strategies/jwt.strategy.ts

@@ -1,11 +1,11 @@
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
 import { ExtractJwt, Strategy } from 'passport-jwt';
+import { Request as RequestType } from 'express';
 import { ConfigService } from '../../../common/services/config.service';
 import { AuthGuardStrategy } from '../auth-guard-strategy.enum';
 import { JwtPayload } from '../interfaces/jwt-payload.interface';
 import { CoreAuthService } from '../services/core-auth.service';
-import { Request as RequestType } from 'express';
 
 /**
  * Use JWT strategy for passport

package/src/core/modules/auth/tokens.decorator.ts

@@ -1,5 +1,4 @@
-import { createParamDecorator, ExecutionContext } from '@nestjs/common';
-import { GqlExecutionContext } from '@nestjs/graphql';
+import { ExecutionContext, createParamDecorator } from '@nestjs/common';
 import { getContextData } from '../../common/helpers/context.helper';
 
 /**
@@ -8,15 +7,15 @@ import { getContextData } from '../../common/helpers/context.helper';
 export const Tokens = createParamDecorator(
   (
     tokenId: 'token' | 'refreshToken' | undefined,
-    ctx: ExecutionContext
+    ctx: ExecutionContext,
   ): string | { token: string; refreshToken: string } => {
     // Get prepared context (REST or GraphQL)
     const context = getContextData(ctx);
 
     // Get token from cookie or authorization header
-    const token =
-      context?.request?.cookies?.['token'] ||
-      context?.request
+    const token
+      = context?.request?.cookies?.['token']
+      || context?.request
         ?.get('Authorization')
         ?.replace(/bearer/i, '')
         .trim();
@@ -32,5 +31,5 @@ export const Tokens = createParamDecorator(
       return tokens[tokenId];
     }
     return tokens;
-  }
+  },
 );

package/src/core/modules/file/core-file-info.model.ts

@@ -25,8 +25,8 @@ export class CoreFileInfo extends CoreModel {
 
   @Field(() => Number, {
     description:
-      'The size of each chunk in bytes. GridFS divides the document into chunks of size chunkSize, ' +
-      'except for the last, which is only as large as needed. The default size is 255 kilobytes (kB)',
+      'The size of each chunk in bytes. GridFS divides the document into chunks of size chunkSize, '
+      + 'except for the last, which is only as large as needed. The default size is 255 kilobytes (kB)',
     nullable: true,
   })
   @Prop({ type: Number, required: false })

package/src/core/modules/file/core-file.controller.ts

@@ -1,6 +1,4 @@
 import { BadRequestException, Controller, Get, NotFoundException, Param, Res } from '@nestjs/common';
-import { CurrentUser } from '../../common/decorators/current-user.decorator';
-import { CoreUserModel } from '../user/core-user.model';
 import { CoreFileService } from './core-file.service';
 
 /**
@@ -17,7 +15,7 @@ export abstract class CoreFileController {
    * Download file
    */
   @Get(':filename')
-  async getFile(@Param('filename') filename: string, @Res() res, @CurrentUser() user: CoreUserModel) {
+  async getFile(@Param('filename') filename: string, @Res() res) {
     if (!filename) {
       throw new BadRequestException('Missing filename for download');
     }
@@ -28,7 +26,7 @@ export abstract class CoreFileController {
     }
     const filestream = await this.fileService.getFileStream(file.id);
     res.header('Content-Type', file.contentType);
-    res.header('Content-Disposition', 'attachment; filename=' + file.filename);
+    res.header('Content-Disposition', `attachment; filename=${file.filename}`);
     return filestream.pipe(res);
   }
 }

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

@@ -1,7 +1,7 @@
 import { NotFoundException } from '@nestjs/common';
 import { GridFSBucket, GridFSBucketReadStream, GridFSBucketReadStreamOptions } from 'mongodb';
 import { Connection, Types } from 'mongoose';
-import { createBucket, MongoGridFSOptions, MongooseGridFS } from 'mongoose-gridfs';
+import { MongoGridFSOptions, MongooseGridFS, createBucket } from 'mongoose-gridfs';
 import { FilterArgs } from '../../common/args/filter.args';
 import { getObjectIds, getStringIds } from '../../common/helpers/db.helper';
 import { convertFilterArgsToQuery } from '../../common/helpers/filter.helper';
@@ -38,6 +38,7 @@ export abstract class CoreFileService {
       return null;
     }
     return await new Promise(async (resolve, reject) => {
+      // eslint-disable-next-line unused-imports/no-unused-vars
       const { filename, mimetype, encoding, createReadStream } = await file;
       const readStream = createReadStream();
       const options: MongoGridFSOptions = { filename, contentType: mimetype };
@@ -123,7 +124,7 @@ export abstract class CoreFileService {
    */
   async getFileStreamByName(
     filename: string,
-    serviceOptions?: FileServiceOptions
+    serviceOptions?: FileServiceOptions,
   ): Promise<GridFSBucketReadStreamOptions> {
     if (!(await this.checkRights(filename, { ...serviceOptions, checkInputType: 'filename' }))) {
       return null;
@@ -182,7 +183,7 @@ export abstract class CoreFileService {
     }
     const fileInfo = await this.getFileInfoByName(filename);
     if (!fileInfo) {
-      throw new NotFoundException('File not found with filename ' + filename);
+      throw new NotFoundException(`File not found with filename ${filename}`);
     }
     return await this.deleteFile(fileInfo.id, serviceOptions);
   }
@@ -196,8 +197,8 @@ export abstract class CoreFileService {
    * Can throw an exception if the rights do not fit
    */
   protected checkRights(
-    input: any,
-    options?: FileServiceOptions & { checkInputType: FileInputCheckType }
+    input: any, // eslint-disable-line unused-imports/no-unused-vars
+    options?: FileServiceOptions & { checkInputType: FileInputCheckType }, // eslint-disable-line unused-imports/no-unused-vars
   ): MaybePromise<boolean> {
     return true;
   }

package/src/core/modules/file/interfaces/file-upload.interface.ts

@@ -1,5 +1,5 @@
-import { WriteStream } from 'fs-capacitor';
 import { Readable } from 'stream';
+import { WriteStream } from 'fs-capacitor';
 
 /**
  * Interface for file uploads

package/src/core/modules/health-check/core-health-check-result.model.ts

@@ -0,0 +1,46 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+import { CoreModel } from '../../common/models/core-model.model';
+import { JSON } from '../../common/scalars/json.scalar';
+
+/**
+ * User model
+ */
+@ObjectType({ description: 'Health check result' })
+export abstract class CoreHealthCheckResult extends CoreModel {
+  // ===================================================================================================================
+  // Properties
+  // ===================================================================================================================
+
+  /**
+   * The overall status of the Health Check
+   */
+  @Field({ description: 'The overall status of the Health Check', nullable: false })
+  status: 'error' | 'ok' | 'shutting_down' = undefined;
+
+  /**
+   * The info object contains information of each health indicator which is of status “up”
+   */
+  @Field(type => JSON, {
+    description: 'The info object contains information of each health indicator which is of status “up”',
+    nullable: true,
+  })
+  info: JSON = undefined;
+
+  /**
+   * The error object contains information of each health indicator which is of status “down”
+   */
+  @Field(type => JSON, {
+    description: 'The error object contains information of each health indicator which is of status “down”',
+    nullable: true,
+  })
+  error: JSON = undefined;
+
+  /**
+   * The details object contains information of every health indicator
+   */
+  @Field(type => JSON, {
+    description: 'The details object contains information of every health indicator',
+    nullable: false,
+  })
+  details: JSON = undefined;
+}

package/src/core/modules/health-check/core-health-check.controller.ts

@@ -0,0 +1,24 @@
+import { Controller, Get } from '@nestjs/common';
+import { CoreHealthCheckService } from './core-health-check.service';
+
+/**
+ * The HealthController class checks the health of various components including the database, memory, and disk.
+ * Inspired by https://mobileappcircular.com/marketplace-backend-creating-a-health-check-endpoint-in-nestjs-app-using-terminus-25727e96c7d2
+ */
+@Controller()
+export class CoreHealthCheckController {
+  constructor(protected readonly healthCheckService: CoreHealthCheckService) {}
+
+  /**
+   * The function checks the health of various components including the database, memory, and storage.
+   * @returns The function is returning the result of calling the `healthCheck()` method
+   * with an array of functions as arguments. Each function in the array is a check for a different
+   * aspect of the system's health, including the status of the database, memory usage, and disk
+   * storage. The `healthCheck()` method will return a Promise that resolves with an array of objects
+   * representing the results of each check
+   */
+  @Get('health-check')
+  async healthCheck() {
+    return this.healthCheckService.healthCheck();
+  }
+}

package/src/core/modules/health-check/core-health-check.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { CoreHealthCheckController } from './core-health-check.controller';
+import { CoreHealthCheckResolver } from './core-health-check.resolver';
+import { CoreHealthCheckService } from './core-health-check.service';
+
+/**
+ * This is a module that imports the TerminusModule and includes a HealthController.
+ * Inspired by https://mobileappcircular.com/marketplace-backend-creating-a-health-check-endpoint-in-nestjs-app-using-terminus-25727e96c7d2
+ */
+@Module({
+  imports: [TerminusModule],
+  controllers: [CoreHealthCheckController],
+  providers: [CoreHealthCheckService, CoreHealthCheckResolver],
+})
+export class CoreHealthCheckModule {
+}

package/src/core/modules/health-check/core-health-check.resolver.ts

@@ -0,0 +1,32 @@
+import { Query, Resolver } from '@nestjs/graphql';
+import { RoleEnum } from '../../common/enums/role.enum';
+import { Roles } from '../../common/decorators/roles.decorator';
+import { CoreHealthCheckResult } from './core-health-check-result.model';
+import { CoreHealthCheckService } from './core-health-check.service';
+
+
+/**
+ * Resolver to process with user data
+ */
+@Resolver(() => CoreHealthCheckResult)
+@Roles(RoleEnum.ADMIN)
+export class CoreHealthCheckResolver {
+  /**
+   * Import services
+   */
+  constructor(protected readonly healthCheckService: CoreHealthCheckService) {
+  }
+
+  // ===========================================================================
+  // Queries
+  // ===========================================================================
+
+  /**
+   * Get heath check result
+   */
+  @Roles(RoleEnum.S_EVERYONE)
+  @Query(() => CoreHealthCheckResult, { description: 'Get health check result' })
+  async healthCheck() {
+    return this.healthCheckService.healthCheck();
+  }
+}

package/src/core/modules/health-check/core-health-check.service.ts

@@ -0,0 +1,62 @@
+import { Injectable } from '@nestjs/common';
+import {
+  DiskHealthIndicator, HealthCheckResult,
+  HealthCheckService,
+  MemoryHealthIndicator,
+  MongooseHealthIndicator,
+} from '@nestjs/terminus';
+import { MongoosePingCheckSettings } from '@nestjs/terminus/dist/health-indicator/database/mongoose.health';
+import { DiskHealthIndicatorOptions } from '@nestjs/terminus/dist/health-indicator/disk/disk-health-options.type';
+import { ConfigService } from '../../common/services/config.service';
+
+/**
+ * Core health check service
+ * Inspired by https://mobileappcircular.com/marketplace-backend-creating-a-health-check-endpoint-in-nestjs-app-using-terminus-25727e96c7d2
+ */
+@Injectable()
+export class CoreHealthCheckService {
+
+  constructor(
+    protected config: ConfigService,
+    protected db: MongooseHealthIndicator,
+    protected disk: DiskHealthIndicator,
+    protected health: HealthCheckService,
+    protected memory: MemoryHealthIndicator,
+  ) {
+  }
+
+  healthCheck(): Promise<HealthCheckResult> {
+    const healthIndicatorFunctions = [];
+    if (this.config.get<boolean>('healthCheck.configs.database.enabled')) {
+      healthIndicatorFunctions.push(() =>
+        this.db.pingCheck(
+          this.config.get<string>('healthCheck.configs.database.key') ?? 'database',
+          this.config.get<MongoosePingCheckSettings>('healthCheck.configs.database.options') ?? { timeout: 300 },
+        ));
+    }
+    if (this.config.get<boolean>('healthCheck.configs.memoryHeap.enabled')) {
+      healthIndicatorFunctions.push(() => this.memory.checkHeap(
+        this.config.get<string>('healthCheck.configs.memoryHeap.key') ?? 'memoryHeap',
+        // memory in bytes (4GB default)
+        this.config.get<number>('healthCheck.configs.memoryHeap.heapUsedThreshold') ?? 4 * 1024 * 1024 * 1024,
+      ));
+    }
+    if (this.config.get<boolean>('healthCheck.configs.memoryRss.enabled')) {
+      healthIndicatorFunctions.push(() => this.memory.checkRSS(
+        this.config.get<string>('healthCheck.configs.memoryRss.key') ?? 'memoryRss',
+        // memory in bytes (4GB default)
+        this.config.get<number>('healthCheck.configs.memoryRss.rssThreshold') ?? 4 * 1024 * 1024 * 1024,
+      ));
+    }
+    if (this.config.get<boolean>('healthCheck.configs.storage.enabled')) {
+      healthIndicatorFunctions.push(() => this.disk.checkStorage(
+        this.config.get<string>('healthCheck.configs.storage.key') ?? 'storage',
+        this.config.get<DiskHealthIndicatorOptions>('healthCheck.configs.storage.options') ?? {
+          thresholdPercent: 0.8,
+          path: '/',
+        },
+      ));
+    }
+    return this.health.check(healthIndicatorFunctions);
+  }
+}

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

@@ -1,5 +1,5 @@
 import { Field, ObjectType } from '@nestjs/graphql';
-import { Prop, raw, Schema as MongooseSchema } from '@nestjs/mongoose';
+import { Schema as MongooseSchema, Prop, raw } from '@nestjs/mongoose';
 import { IsEmail, IsOptional } from 'class-validator';
 import { Document } from 'mongoose';
 import { CorePersistenceModel } from '../../common/models/core-persistence.model';
@@ -50,9 +50,9 @@ export abstract class CoreUserModel extends CorePersistenceModel {
   /**
    * Roles of the user
    */
-  @Field((type) => [String], { description: 'Roles of the user', nullable: true })
+  @Field(type => [String], { description: 'Roles of the user', nullable: true })
   @IsOptional()
-  @Prop()
+  @Prop([String])
   roles: string[] = undefined;
 
   /**
@@ -89,7 +89,7 @@ export abstract class CoreUserModel extends CorePersistenceModel {
   /**
    * Verification of the user
    */
-  @Field((type) => Boolean, { description: 'Verification state of the user', nullable: true })
+  @Field(type => Boolean, { description: 'Verification state of the user', nullable: true })
   @Prop({ type: Boolean })
   verified: boolean = undefined;
 
@@ -114,7 +114,7 @@ export abstract class CoreUserModel extends CorePersistenceModel {
     if (!this.roles || this.roles.length < 1) {
       return false;
     }
-    return !roles || roles.length < 1 ? true : this.roles.some((role) => roles.includes(role));
+    return !roles || roles.length < 1 ? true : this.roles.some(role => roles.includes(role));
   }
 
   /**
@@ -127,7 +127,7 @@ export abstract class CoreUserModel extends CorePersistenceModel {
     if (!this.roles || this.roles.length < 1) {
       return false;
     }
-    return !roles ? true : roles.every((role) => this.roles.includes(role));
+    return !roles ? true : roles.every(role => this.roles.includes(role));
   }
 
   /**