@lenne.tech/nest-server 10.0.0 → 10.0.3

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

@@ -13,7 +13,7 @@ import { ModuleService } from './module.service';
 export abstract class CrudService<
   Model extends CoreModel = any,
   CreateInput = any,
-  UpdateInput = any
+  UpdateInput = any,
 > extends ModuleService<Model> {
   /**
    * Create item
@@ -25,7 +25,7 @@ export abstract class CrudService<
         const currentUserId = serviceOptions?.currentUser?.id;
         return new this.mainDbModel({ ...data.input, createdBy: currentUserId, updatedBy: currentUserId }).save();
       },
-      { input, serviceOptions }
+      { input, serviceOptions },
     );
   }
 
@@ -87,7 +87,7 @@ export abstract class CrudService<
    */
   async find(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
-    serviceOptions?: ServiceOptions
+    serviceOptions?: ServiceOptions,
   ): Promise<Model[]> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
     // and should not be processed as FilterArgs
@@ -118,7 +118,7 @@ export abstract class CrudService<
         }
         return find.exec();
       },
-      { input: filter, serviceOptions }
+      { input: filter, serviceOptions },
     );
   }
 
@@ -128,7 +128,7 @@ export abstract class CrudService<
    */
   async findForce(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
-    serviceOptions: ServiceOptions = {}
+    serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
@@ -141,7 +141,7 @@ export abstract class CrudService<
    */
   async findRaw(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
-    serviceOptions: ServiceOptions = {}
+    serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
@@ -154,7 +154,7 @@ export abstract class CrudService<
    */
   async findAndCount(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
-    serviceOptions?: ServiceOptions
+    serviceOptions?: ServiceOptions,
   ): Promise<{ items: Model[]; totalCount: number }> {
     // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
     // and should not be processed as FilterArgs
@@ -217,13 +217,13 @@ export abstract class CrudService<
 
         // Find and process db items
         const collation = serviceOptions?.collation || ConfigService.get('mongoose.collation');
-        const dbResult =
-          (await this.mainDbModel.aggregate(aggregation, collation ? { collation } : {}).exec())[0] || {};
+        const dbResult
+          = (await this.mainDbModel.aggregate(aggregation, collation ? { collation } : {}).exec())[0] || {};
         dbResult.totalCount = dbResult.totalCount?.[0]?.total || 0;
-        dbResult.items = dbResult.items?.map((item) => this.mainDbModel.hydrate(item)) || [];
+        dbResult.items = dbResult.items?.map(item => this.mainDbModel.hydrate(item)) || [];
         return dbResult;
       },
-      { input: filter, outputPath: 'items', serviceOptions }
+      { input: filter, outputPath: 'items', serviceOptions },
     );
   }
 
@@ -233,7 +233,7 @@ export abstract class CrudService<
    */
   async findAndCountForce(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
-    serviceOptions: ServiceOptions = {}
+    serviceOptions: ServiceOptions = {},
   ): Promise<{ items: Model[]; totalCount: number }> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
@@ -246,7 +246,7 @@ export abstract class CrudService<
    */
   async findAndCountRaw(
     filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
-    serviceOptions: ServiceOptions = {}
+    serviceOptions: ServiceOptions = {},
   ): Promise<{ items: Model[]; totalCount: number }> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
@@ -260,7 +260,7 @@ export abstract class CrudService<
   async findAndUpdate(
     filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     update: PlainObject<UpdateInput>,
-    serviceOptions?: ServiceOptions
+    serviceOptions?: ServiceOptions,
   ): Promise<Model[]> {
     const dbItems: Model[] = await this.find(filter, serviceOptions);
     if (!dbItems?.length) {
@@ -276,7 +276,7 @@ export abstract class CrudService<
           } catch (e) {
             reject(e);
           }
-        })
+        }),
       );
     }
     return await Promise.all(promises);
@@ -289,7 +289,7 @@ export abstract class CrudService<
   async findAndUpdateForce(
     filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     update: PlainObject<UpdateInput>,
-    serviceOptions: ServiceOptions = {}
+    serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.force = true;
@@ -303,7 +303,7 @@ export abstract class CrudService<
   async findAndUpdateRaw(
     filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
     update: PlainObject<UpdateInput>,
-    serviceOptions: ServiceOptions = {}
+    serviceOptions: ServiceOptions = {},
   ): Promise<Model[]> {
     serviceOptions = serviceOptions || {};
     serviceOptions.prepareInput = null;
@@ -329,7 +329,7 @@ export abstract class CrudService<
    */
   async read(
     input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
-    serviceOptions?: ServiceOptions
+    serviceOptions?: ServiceOptions,
   ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
       return this.get(input, serviceOptions);
@@ -359,7 +359,7 @@ export abstract class CrudService<
    */
   async readForce(
     input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
-    serviceOptions?: ServiceOptions
+    serviceOptions?: ServiceOptions,
   ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
       return this.getForce(input, serviceOptions);
@@ -389,7 +389,7 @@ export abstract class CrudService<
    */
   async readRaw(
     input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
-    serviceOptions?: ServiceOptions
+    serviceOptions?: ServiceOptions,
   ): Promise<Model | Model[]> {
     if (typeof input === 'string') {
       return this.getRaw(input, serviceOptions);
@@ -412,7 +412,7 @@ export abstract class CrudService<
         const merged = mergePlain(dbObject, data.input, { updatedBy: currentUserId });
         return await this.mainDbModel.findByIdAndUpdate(id, merged, { returnDocument: 'after' }).exec();
       },
-      { dbObject, input, serviceOptions }
+      { dbObject, input, serviceOptions },
     );
   }
 
@@ -450,7 +450,7 @@ export abstract class CrudService<
         await this.mainDbModel.findByIdAndDelete(id).exec();
         return dbObject;
       },
-      { dbObject, serviceOptions }
+      { dbObject, serviceOptions },
     );
   }
 

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

@@ -30,7 +30,7 @@ export class EmailService {
       templateData?: { [key: string]: any };
       text?: string;
       textTemplate?: string;
-    }
+    },
   ): Promise<any> {
     // Process config
     const { attachments, htmlTemplate, senderName, senderEmail, templateData, textTemplate } = {

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

@@ -1,6 +1,6 @@
 import { HttpException, Injectable } from '@nestjs/common';
-import { ConfigService } from './config.service';
 import Mailjet from 'node-mailjet';
+import { ConfigService } from './config.service';
 
 /**
  * Mailjet service
@@ -30,7 +30,7 @@ export class MailjetService {
       }[];
       templateData?: { [key: string]: any };
       sandbox?: boolean;
-    }
+    },
   ) {
     // Process config
     const { senderName, senderEmail, templateData, attachments, sandbox } = {
@@ -81,24 +81,24 @@ export class MailjetService {
       });
     } catch (e) {
       if (
-        this.configService.getFastButReadOnly('email.mailjet.api_key_public') &&
-        this.configService.getFastButReadOnly('email.mailjet.api_key_private')
+        this.configService.getFastButReadOnly('email.mailjet.api_key_public')
+        && this.configService.getFastButReadOnly('email.mailjet.api_key_private')
       ) {
         throw new HttpException('Cannot connect to mailjet.', 502);
       }
       console.debug(
         JSON.stringify(
           {
-            info: 'Mailjet credentials are missing',
+            'info': 'Mailjet credentials are missing',
             'email.mailjet.api_key_public':
               this.configService.getFastButReadOnly('email.mailjet.api_key_public') || 'missing',
             'email.mailjet.api_key_private':
               this.configService.getFastButReadOnly('email.mailjet.api_key_private') || 'missing',
-            templateData: templateData,
+            'templateData': templateData,
           },
           null,
-          2
-        )
+          2,
+        ),
       );
       return;
     }

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

@@ -53,7 +53,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
       processType?: ProcessType;
       roles?: string | string[];
       throwError?: boolean;
-    }
+    },
   ): Promise<any> {
     const config = {
       ...options,
@@ -77,7 +77,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
       outputPath?: string | string[];
       input?: any;
       serviceOptions?: ServiceOptions;
-    }
+    },
   ) {
     // Configuration with default values
     const config: {
@@ -151,10 +151,9 @@ export abstract class ModuleService<T extends CoreModel = any> {
         opts.metatype = config.inputType;
       }
       config.input = await this.checkRights(config.input, config.currentUser as any, opts);
-    }
 
-    // Check roles before processing the service function if they were not already checked during the input check
-    else if (!config.input && config.checkRights && this.checkRights) {
+      // Check roles before processing the service function if they were not already checked during the input check
+    } else if (!config.input && config.checkRights && this.checkRights) {
       await this.checkRights(undefined, config.currentUser as any, config);
     }
 
@@ -240,7 +239,7 @@ export abstract class ModuleService<T extends CoreModel = any> {
       model?: new (...args: any[]) => T;
       dbModel?: Model<T & Document>;
       ignoreSelections?: boolean;
-    } = {}
+    } = {},
   ) {
     const config = {
       model: this.mainModelConstructor,

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

@@ -1,8 +1,8 @@
+import fs = require('fs');
+import { join } from 'path';
 import { Injectable } from '@nestjs/common';
 import ejs = require('ejs');
 import { TemplateFunction } from 'ejs';
-import fs = require('fs');
-import { join } from 'path';
 import { ConfigService } from './config.service';
 
 /**
@@ -44,7 +44,7 @@ export class TemplateService {
 
       // Get template file
       fs.readFile(
-        join(this.configService.getFastButReadOnly('templates.path'), filePath) + '.ejs',
+        `${join(this.configService.getFastButReadOnly('templates.path'), filePath)}.ejs`,
         { encoding: 'utf8' },
         (err, data) => {
           if (err) {
@@ -54,7 +54,7 @@ export class TemplateService {
             this.templates[filePath] = ejs.compile(data);
             resolve(this.templates[filePath]);
           }
-        }
+        },
       );
     });
   }

package/src/core/common/types/core-model-constructor.type.ts

@@ -1,6 +1,6 @@
 import { CoreModel } from '../models/core-model.model';
 
-export type CoreModelConstructor<T extends CoreModel> = {
+export interface CoreModelConstructor<T extends CoreModel> {
   new (): T;
   init(this: new (...args: any[]) => T, ...args: any[]): T;
   map(
@@ -27,4 +27,4 @@ export type CoreModelConstructor<T extends CoreModel> = {
       mapId?: boolean;
     }
   ): T;
-};
+}

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);
   }
 }