@lenne.tech/nest-server 3.1.2 → 3.3.0

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

@@ -1,20 +1,14 @@
-import {
-  BadRequestException,
-  NotFoundException,
-  UnauthorizedException,
-  UnprocessableEntityException,
-} from '@nestjs/common';
+import { BadRequestException, NotFoundException, UnprocessableEntityException } from '@nestjs/common';
 import * as bcrypt from 'bcrypt';
 import { PubSub } from 'graphql-subscriptions';
 import { FilterArgs } from '../../common/args/filter.args';
-import { RoleEnum } from '../../common/enums/role.enum';
 import { Filter } from '../../common/helpers/filter.helper';
+import { ServiceHelper } from '../../common/helpers/service.helper';
 import { CoreBasicUserService } from './core-basic-user.service';
 import { CoreUserModel } from './core-user.model';
 import { CoreUserCreateInput } from './inputs/core-user-create.input';
 import { CoreUserInput } from './inputs/core-user.input';
-import { Model } from 'mongoose';
-import * as _ from 'lodash';
+import { Model, Document } from 'mongoose';
 import * as crypto from 'crypto';
 import envConfig from '../../../config.env';
 import { EmailService } from '../../common/services/email.service';
@@ -30,7 +24,7 @@ export abstract class CoreUserService<
   TUserInput extends CoreUserInput,
   TUserCreateInput extends CoreUserCreateInput
 > extends CoreBasicUserService<TUser, TUserInput, TUserCreateInput> {
-  protected constructor(protected readonly userModel: Model<any>, protected emailService: EmailService) {
+  protected constructor(protected readonly userModel: Model<TUser & Document>, protected emailService: EmailService) {
     super(userModel);
   }
 
@@ -45,11 +39,11 @@ export abstract class CoreUserService<
     // Prepare input
     await this.prepareInput(input, currentUser, { create: true });
 
-    // Generate verification token
-    const newUser = { ...input, ...{ verificationToken: crypto.randomBytes(32).toString('hex') } };
-
     // Create new user
-    const createdUser = new this.userModel(this.model.map(newUser));
+    const createdUser = new this.userModel({
+      ...input,
+      verificationToken: crypto.randomBytes(32).toString('hex'),
+    });
 
     try {
       // Save created user
@@ -63,13 +57,13 @@ export abstract class CoreUserService<
     }
 
     // Prepare output
-    await this.prepareOutput(createdUser, args[0]);
+    const preparedUser = await this.prepareOutput(this.model.map(createdUser), args[0]);
 
     // Inform subscriber
-    pubSub.publish('userCreated', { userCreated: createdUser });
+    pubSub.publish('userCreated', { userCreated: preparedUser });
 
     // Return created user
-    return createdUser;
+    return preparedUser;
   }
 
   /**
@@ -77,7 +71,7 @@ export abstract class CoreUserService<
    */
   async delete(id: string, ...args: any[]): Promise<TUser> {
     // Search user
-    let user = await this.userModel.findOne({ _id: id }).exec();
+    const user = await this.userModel.findById(id).exec();
 
     // Check user
     if (!user) {
@@ -85,19 +79,23 @@ export abstract class CoreUserService<
     }
 
     // Delete user
-    await this.userModel.deleteOne({ _id: id }).exec();
+    await user.delete();
+
+    // Prepare output
+    const deletedUser = await this.prepareOutput(this.model.map(user), args[0]);
 
-    user = this.model.map(user);
+    // Inform subscriber
+    pubSub.publish('userDeleted', { userDeleted: deletedUser });
 
     // Return deleted user
-    return await this.prepareOutput(user, args[0]);
+    return deletedUser;
   }
 
   /**
    * Get user via ID
    */
   async get(id: string, ...args: any[]): Promise<TUser> {
-    const user = await this.userModel.findOne({ _id: id }).exec();
+    const user = await this.userModel.findById(id).exec();
 
     if (!user) {
       throw new NotFoundException();
@@ -116,17 +114,15 @@ export abstract class CoreUserService<
       (
         await this.userModel.find(filterQuery[0], null, filterQuery[1]).exec()
       ).map((user) => {
-        return this.prepareOutput(user, args[0]);
+        return this.prepareOutput(this.model.map(user), args[0]);
       })
     );
   }
 
   /**
    * Verify user with token
-   *
-   * @param token
    */
-  async verify(token: string): Promise<boolean> {
+  async verify(token: string, ...args: any[]): Promise<TUser> {
     const user = await this.userModel.findOne({ verificationToken: token }).exec();
 
     if (!user) {
@@ -141,59 +137,65 @@ export abstract class CoreUserService<
       throw new Error('User already verified');
     }
 
-    await this.userModel.findByIdAndUpdate(user.id, { $set: { verified: true, verificationToken: null } }).exec();
+    // Update user
+    await Object.assign(user, {
+      verified: true,
+      verificationToken: null,
+    }).save();
+
+    // Prepare verified user
+    const verifiedUser = this.prepareOutput(this.model.map(user), args[0]);
+
+    // Inform subscriber
+    pubSub.publish('userVerified', { userVerified: verifiedUser });
 
-    return true;
+    // Return prepared verified user
+    return verifiedUser;
   }
 
   /**
    * Set newpassword for user with token
-   *
-   * @param token
-   * @param newPassword
    */
-  async resetPassword(token: string, newPassword: string): Promise<boolean> {
+  async resetPassword(token: string, newPassword: string, ...args: any[]): Promise<TUser> {
     const user = await this.userModel.findOne({ passwordResetToken: token }).exec();
 
     if (!user) {
       throw new NotFoundException();
     }
 
-    const cryptedPassword = await bcrypt.hash(newPassword, 10);
-    await this.userModel
-      .findByIdAndUpdate(user.id, { $set: { password: cryptedPassword, passwordResetToken: null } })
-      .exec();
+    // Update user
+    await Object.assign(user, {
+      password: await bcrypt.hash(newPassword, 10),
+      passwordResetToken: null,
+    }).save();
 
-    return true;
+    // Return prepared user with changed password
+    return this.prepareOutput(this.model.map(user), args[0]);
   }
 
   /**
-   * Request email with password reset link
-   *
-   * @param email
+   * Set password rest token for email
    */
-  async requestPasswordResetMail(email: string): Promise<boolean> {
+  async setPasswordResetTokenForEmail(email: string, ...args: any[]): Promise<TUser> {
     const user = await this.userModel.findOne({ email }).exec();
 
     if (!user) {
       throw new NotFoundException();
     }
 
+    // Set reset token
     const resetToken = crypto.randomBytes(32).toString('hex');
-    await this.userModel.findByIdAndUpdate(user.id, { $set: { passwordResetToken: resetToken } }).exec();
-
-    await this.emailService.sendMail(user.email, 'Password reset', {
-      htmlTemplate: 'password-reset',
-      templateData: { name: user.username, link: envConfig.email.passwordResetLink + '/' + resetToken },
-    });
+    user.passwordResetToken = resetToken;
+    await user.save();
 
-    return true;
+    // Return user who want to reset the password
+    return this.prepareOutput(this.model.map(user), args[0]);
   }
 
   /**
    * Set roles for specified user
    */
-  async setRoles(userId: string, roles: string[]): Promise<TUser> {
+  async setRoles(userId: string, roles: string[], ...args: any[]): Promise<TUser> {
     // Check roles
     if (!Array.isArray(roles)) {
       throw new BadRequestException('Missing roles');
@@ -205,7 +207,8 @@ export abstract class CoreUserService<
     }
 
     // Update and return user
-    return this.userModel.findByIdAndUpdate(userId, { roles }).exec();
+    const user = await this.userModel.findByIdAndUpdate(userId, { roles }).exec();
+    return this.prepareOutput(this.model.map(user), args[0]);
   }
 
   /**
@@ -213,7 +216,7 @@ export abstract class CoreUserService<
    */
   async update(id: string, input: TUserInput, currentUser: TUser, ...args: any[]): Promise<TUser> {
     // Check if user exists
-    let user = await this.userModel.findOne({ _id: id }).exec();
+    const user = await this.userModel.findById(id).exec();
 
     if (!user) {
       throw new NotFoundException(`User not found with ID: ${id}`);
@@ -223,16 +226,10 @@ export abstract class CoreUserService<
     await this.prepareInput(input, currentUser);
 
     // Update
-    user.set(input);
-
-    // Save
-    await user.save();
-
-    // Map for response
-    user = this.model.map(user);
+    await Object.assign(user, input).save();
 
     // Return user
-    return await this.prepareOutput(user as TUser, args[0]);
+    return await this.prepareOutput(this.model.map(user), args[0]);
   }
 
   // ===================================================================================================================
@@ -243,44 +240,12 @@ export abstract class CoreUserService<
    * Prepare input before save
    */
   protected async prepareInput(
-    input: { [key: string]: any },
+    input: Record<string, any>,
     currentUser?: TUser,
     options: { [key: string]: any; checkRoles?: boolean; clone?: boolean } = {},
     ...args: any[]
   ) {
-    // Configuration
-    const config = {
-      checkRoles: true,
-      clone: false,
-      ...options,
-    };
-
-    // Clone input
-    if (config.clone) {
-      input = JSON.parse(JSON.stringify(input));
-    }
-
-    // Process roles
-    if (input.roles && config.checkRoles && (!currentUser?.hasRole || !currentUser.hasRole(RoleEnum.ADMIN))) {
-      if (!(currentUser as any)?.roles) {
-        throw new UnauthorizedException('Missing roles of current user');
-      } else {
-        const allowedRoles = _.intersection(input.roles, (currentUser as any).roles);
-        if (allowedRoles.length !== input.roles.length) {
-          const missingRoles = _.difference(input.roles, (currentUser as any).roles);
-          throw new UnauthorizedException('Current user not allowed setting roles: ' + missingRoles);
-        }
-        input.roles = allowedRoles;
-      }
-    }
-
-    // Hash password
-    if (input.password) {
-      input.password = await bcrypt.hash((input as any).password, 10);
-    }
-
-    // Return prepared input
-    return input;
+    return ServiceHelper.prepareInput(input, currentUser, options);
   }
 
   /**
@@ -291,27 +256,6 @@ export abstract class CoreUserService<
     options: { [key: string]: any; clone?: boolean } = {},
     ...args: any[]
   ): Promise<TUser> {
-    // Configuration
-    const config = {
-      clone: true,
-      ...options,
-    };
-
-    // Clone user
-    if (config.clone) {
-      user = JSON.parse(JSON.stringify(user));
-    }
-
-    // Remove password if exists
-    delete (user as any).password;
-
-    // Remove verification token if exists
-    delete (user as any).verificationToken;
-
-    // Remove password reset token if exists
-    delete (user as any).passwordResetToken;
-
-    // Return prepared user
-    return user;
+    return ServiceHelper.prepareOutput(user, options);
   }
 }

package/src/core/modules/user/inputs/core-user-create.input.ts

@@ -4,10 +4,14 @@ import { CoreUserInput } from './core-user.input';
 
 /**
  * User input to create a new user
+ *
+ * HINT: All properties (in this class and all classes that extend this class) must be initialized with undefined,
+ * otherwise the property will not be recognized via Object.keys (this is necessary for mapping) or will be initialized
+ * with a default value that may overwrite an existing value in the DB.
  */
 @InputType({ description: 'User input to create a new user', isAbstract: true })
 export abstract class CoreUserCreateInput extends CoreUserInput {
   @Field({ description: 'Email of the user', nullable: false })
   @IsEmail()
-  email: string;
+  email: string = undefined;
 }

package/src/core/modules/user/inputs/core-user.input.ts

@@ -2,53 +2,58 @@ import { IsEmail, IsOptional } from 'class-validator';
 import { Field, InputType } from '@nestjs/graphql';
 import { Restricted } from '../../../common/decorators/restricted.decorator';
 import { RoleEnum } from '../../../common/enums/role.enum';
+import { CoreInput } from '../../../common/inputs/core-input.input';
 
 /**
  * User input to update a user
+ *
+ * HINT: All properties (in this class and all classes that extend this class) must be initialized with undefined,
+ * otherwise the property will not be recognized via Object.keys (this is necessary for mapping) or will be initialized
+ * with a default value that may overwrite an existing value in the DB.
  */
 @InputType({ description: 'User input', isAbstract: true })
-export abstract class CoreUserInput {
+export abstract class CoreUserInput extends CoreInput {
   /**
    * Email of the user
    */
   @Field({ description: 'Email of the user', nullable: true })
   @IsOptional()
   @IsEmail()
-  email?: string;
+  email?: string = undefined;
 
   /**
    * First name of the user
    */
   @Field({ description: 'First name of the user', nullable: true })
   @IsOptional()
-  firstName?: string;
+  firstName?: string = undefined;
 
   /**
    * Last name of the user
    */
   @Field({ description: 'Last name of the user', nullable: true })
   @IsOptional()
-  lastName?: string;
+  lastName?: string = undefined;
 
   /**
    * Roles of the user
    */
-  @Restricted(RoleEnum.ADMIN, RoleEnum.OWNER)
+  @Restricted(RoleEnum.ADMIN)
   @Field((type) => [String], { description: 'Roles of the user', nullable: true })
   @IsOptional()
-  roles?: string[];
+  roles?: string[] = undefined;
 
   /**
    * Username / alias of the user
    */
   @Field({ description: 'Username / alias of the user', nullable: true })
   @IsOptional()
-  username?: string;
+  username?: string = undefined;
 
   /**
    * Password of the user
    */
   @Field({ description: 'Password of the user', nullable: true })
   @IsOptional()
-  password?: string;
+  password?: string = undefined;
 }

package/src/core.module.ts

@@ -1,10 +1,10 @@
-import { DynamicModule, Global, Module, Scope } from '@nestjs/common';
+import { DynamicModule, Global, Module } from '@nestjs/common';
 import { APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
 import { GraphQLModule } from '@nestjs/graphql';
 import { Config } from './core/common/helpers/config.helper';
 import { CheckResponseInterceptor } from './core/common/interceptors/check-response.interceptor';
 import { IServerOptions } from './core/common/interfaces/server-options.interface';
-import { CheckInputPipe } from './core/common/pipes/check-input.pipe';
+import { MapAndValidatePipe } from './core/common/pipes/map-and-validate.pipe';
 import { ConfigService } from './core/common/services/config.service';
 import { EmailService } from './core/common/services/email.service';
 import { TemplateService } from './core/common/services/template.service';
@@ -82,11 +82,17 @@ export class CoreModule {
       },
 
       // [Global] The CheckInputPipe checks the permissibility of individual properties of inputs for the resolvers
-      // in relation to the current user
+      // in relation to the current user, replaces MapAndValidatePipe
+      // Does not work yet, because context is missing: https://github.com/nestjs/graphql/issues/325
+      // {
+      //   provide: APP_PIPE,
+      //   useClass: CheckInputPipe,
+      // },
+
+      // [Global] Map plain objects to metatype and validate
       {
         provide: APP_PIPE,
-        scope: Scope.REQUEST,
-        useClass: CheckInputPipe,
+        useClass: MapAndValidatePipe,
       },
 
       // Core Services

package/src/index.ts

@@ -26,22 +26,26 @@ export * from './core/common/helpers/input.helper';
 export * from './core/common/helpers/model.helper';
 export * from './core/common/helpers/service.helper';
 export * from './core/common/inputs/combined-filter.input';
+export * from './core/common/inputs/core-input.input';
 export * from './core/common/inputs/filter.input';
 export * from './core/common/inputs/single-filter.input';
 export * from './core/common/inputs/sort.input';
 export * from './core/common/interceptors/check-response.interceptor';
 export * from './core/common/interfaces/core-persistence-model.interface';
+export * from './core/common/interfaces/mailjet-options.interface';
 export * from './core/common/interfaces/server-options.interface';
 export * from './core/common/models/core-model.model';
 export * from './core/common/models/core-persistence.model';
 export * from './core/common/pipes/check-input.pipe';
+export * from './core/common/pipes/map-and-validate.pipe';
 export * from './core/common/scalars/any.scalar';
 export * from './core/common/scalars/date.scalar';
 export * from './core/common/scalars/json.scalar';
 export * from './core/common/services/config.service';
 export * from './core/common/services/email.service';
-export * from './core/common/services/template.service';
 export * from './core/common/services/mailjet.service';
+export * from './core/common/services/template.service';
+export * from './core/common/types/plain-input.type';
 
 // =====================================================================================================================
 // Core - Modules - Auth
@@ -64,8 +68,8 @@ export * from './core/modules/auth/jwt.strategy';
 
 export * from './core/modules/user/inputs/core-user.input';
 export * from './core/modules/user/inputs/core-user-create.input';
-export * from './core/modules/user/core-user.model';
 export * from './core/modules/user/core-basic-user.service';
+export * from './core/modules/user/core-user.model';
 export * from './core/modules/user/core-user.service';
 
 // =====================================================================================================================

package/src/server/common/models/persistence.model.ts

@@ -37,4 +37,17 @@ export abstract class PersistenceModel extends CorePersistenceModel {
   })
   @Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'User' })
   updatedBy?: User = undefined;
+
+  // ===========================================================================
+  // Properties
+  // ===========================================================================
+
+  /**
+   * Initialize instance with default values instead of undefined
+   */
+  init() {
+    super.init();
+    // Nothing more to initialize yet
+    return this;
+  }
 }

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

@@ -16,4 +16,17 @@ export class Auth extends CoreAuthModel {
    */
   @Field((type) => User, { description: 'User who signed in' })
   user: User = undefined;
+
+  // ===================================================================================================================
+  // Properties
+  // ===================================================================================================================
+
+  /**
+   * Initialize instance with default values instead of undefined
+   */
+  init() {
+    super.init();
+    // Nothing more to initialize yet
+    return this;
+  }
 }

package/src/server/modules/user/inputs/user-create.input.ts

@@ -3,6 +3,10 @@ import { CoreUserCreateInput } from '../../../../core/modules/user/inputs/core-u
 
 /**
  * User input to create a new user
+ *
+ * HINT: All properties (in this class and all classes that extend this class) must be initialized with undefined,
+ * otherwise the property will not be recognized via Object.keys (this is necessary for mapping) or will be initialized
+ * with a default value that may overwrite an existing value in the DB.
  */
 @InputType({ description: 'User input to create a new user' })
 export class UserCreateInput extends CoreUserCreateInput {

package/src/server/modules/user/inputs/user.input.ts

@@ -3,6 +3,10 @@ import { CoreUserInput } from '../../../../core/modules/user/inputs/core-user.in
 
 /**
  * User input to update a user
+ *
+ * HINT: All properties (in this class and all classes that extend this class) must be initialized with undefined,
+ * otherwise the property will not be recognized via Object.keys (this is necessary for mapping) or will be initialized
+ * with a default value that may overwrite an existing value in the DB.
  */
 @InputType({ description: 'User input' })
 export class UserInput extends CoreUserInput {

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

@@ -1,16 +1,16 @@
 import { Field, ObjectType } from '@nestjs/graphql';
 import { CoreUserModel } from '../../../core/modules/user/core-user.model';
 import { PersistenceModel } from '../../common/models/persistence.model';
-import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import * as mongoose from 'mongoose';
+import { Prop, Schema as MongooseSchema, SchemaFactory } from '@nestjs/mongoose';
+import { Schema, Document } from 'mongoose';
 
 export type UserDocument = User & Document;
 
 /**
  * User schema
  */
-@Schema()
 @ObjectType({ description: 'User' })
+@MongooseSchema({ timestamps: true })
 export class User extends CoreUserModel implements PersistenceModel {
   // ===================================================================================================================
   // Properties
@@ -32,7 +32,7 @@ export class User extends CoreUserModel implements PersistenceModel {
     description: 'ID of the user who created the object',
     nullable: true,
   })
-  @Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'User' })
+  @Prop({ type: Schema.Types.ObjectId, ref: 'User' })
   createdBy: User = undefined;
 
   /**
@@ -44,8 +44,21 @@ export class User extends CoreUserModel implements PersistenceModel {
     description: 'ID of the user who last updated the object',
     nullable: true,
   })
-  @Prop({ type: mongoose.Schema.Types.ObjectId, ref: 'User' })
+  @Prop({ type: Schema.Types.ObjectId, ref: 'User' })
   updatedBy: User = undefined;
+
+  // ===================================================================================================================
+  // Methods
+  // ===================================================================================================================
+
+  /**
+   * Initialize instance with default values instead of undefined
+   */
+  init() {
+    super.init();
+    // Nothing more to initialize yet
+    return this;
+  }
 }
 
 export const UserSchema = SchemaFactory.createForClass(User);

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

@@ -47,8 +47,8 @@ export class UserResolver {
    * Request new password for user with email
    */
   @Query((returns) => Boolean, { description: 'Request new password for user with email' })
-  async requestPasswordResetMail(@Args('email') email: string) {
-    return await this.usersService.requestPasswordResetMail(email);
+  async requestPasswordResetMail(@Args('email') email: string): Promise<boolean> {
+    return !!(await this.usersService.sendPasswordResetMail(email));
   }
 
   // ===========================================================================
@@ -58,28 +58,29 @@ export class UserResolver {
    * Verify user with email
    */
   @Mutation((returns) => Boolean, { description: 'Verify user with email' })
-  async verifyUser(@Args('token') token: string) {
-    return await this.usersService.verify(token);
+  async verifyUser(@Args('token') token: string): Promise<boolean> {
+    return !!(await this.usersService.verify(token));
   }
 
   /**
    * Set new password for user with token
    */
   @Mutation((returns) => Boolean, { description: 'Set new password for user with token' })
-  async resetPassword(@Args('token') token: string, @Args('password') password: string) {
-    return await this.usersService.resetPassword(token, password);
+  async resetPassword(@Args('token') token: string, @Args('password') password: string): Promise<boolean> {
+    return !!(await this.usersService.resetPassword(token, password));
   }
 
   /**
    * Create new user
    */
   @Mutation((returns) => User, { description: 'Create a new user' })
-  async createUser(
-    @Args('input') input: UserCreateInput,
-    @GraphQLUser() user: User,
-    @Info() info: GraphQLResolveInfo
-  ): Promise<User> {
-    return await this.usersService.create(input, user, info);
+  async createUser(@Args('input') input: UserCreateInput, @GraphQLUser() user: User): Promise<User> {
+    // Check input
+    // Hint: necessary as long as global CheckInputPipe can't access context for current user
+    // (see https://github.com/nestjs/graphql/issues/325)
+    input = await InputHelper.check(input, user, UserCreateInput);
+
+    return await this.usersService.create(input, user);
   }
 
   /**
@@ -87,19 +88,14 @@ export class UserResolver {
    */
   @Roles(RoleEnum.ADMIN, RoleEnum.OWNER)
   @Mutation((returns) => User, { description: 'Update existing user' })
-  async updateUser(
-    @Args('input') input: UserInput,
-    @Args('id') id: string,
-    @GraphQLUser() user: User,
-    @Info() info: GraphQLResolveInfo
-  ): Promise<User> {
+  async updateUser(@Args('input') input: UserInput, @Args('id') id: string, @GraphQLUser() user: User): Promise<User> {
     // Check input
     // Hint: necessary as long as global CheckInputPipe can't access context for current user
     // (see https://github.com/nestjs/graphql/issues/325)
     input = await InputHelper.check(input, user, UserInput);
 
     // Update user
-    return await this.usersService.update(id, input, user, info);
+    return await this.usersService.update(id, input, user);
   }
 
   /**