@lenne.tech/nest-server 3.1.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Modern, fast, powerful Node.js web framework in TypeScript based on Nest with a GraphQL API and a connection to MongoDB (or other databases).",
   "keywords": [
     "node",

package/src/core/common/decorators/restricted.decorator.ts

@@ -73,10 +73,12 @@ export const checkRestricted = (
           ) {
             // User is not the owner
             delete data[propertyKey];
+            continue;
           }
         } else {
           // The user does not have the required rights
           delete data[propertyKey];
+          continue;
         }
       }
     }

package/src/core/common/helpers/model.helper.ts

@@ -77,6 +77,9 @@ export class ModelHelper {
     // Merge target with prepared source
     Object.assign(target, preparedSource);
 
+    // Remove all props with undefined
+    Object.keys(target).forEach((key) => target[key] === undefined && delete target[key]);
+
     // Return target
     return target;
   }

package/src/core/common/helpers/service.helper.ts

@@ -18,7 +18,7 @@ export class ServiceHelper {
   ) {
     // Configuration
     const config = {
-      checkRoles: true,
+      checkRoles: false,
       clone: false,
       create: false,
       ...options,
@@ -65,11 +65,11 @@ export class ServiceHelper {
   /**
    * Prepare output before return
    */
-  static async prepareOutput(
+  static async prepareOutput<T = Record<string, any>>(
     output: any,
     userModel: new () => any,
     userService: any,
-    options: { [key: string]: any; clone?: boolean } = {},
+    options: { [key: string]: any; clone?: boolean; targetModel?: Partial<T> } = {},
     ...args: any[]
   ) {
     // Configuration
@@ -83,6 +83,11 @@ export class ServiceHelper {
       output = JSON.parse(JSON.stringify(output));
     }
 
+    // Map output if target model exist
+    if (options.targetModel) {
+      (options.targetModel as any).map(output);
+    }
+
     // Remove password if exists
     delete output.password;
 

package/src/core/common/pipes/map.pipe.ts

@@ -0,0 +1,16 @@
+import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';
+
+@Injectable()
+export class MapPipe implements PipeTransform {
+  transform(value: any, metadata: ArgumentMetadata) {
+    let result = value;
+
+    // Check map function is available
+    if ((metadata.metatype as any)?.map) {
+      // Map object to correct type
+      result = (metadata.metatype as any).map(value);
+    }
+
+    return result;
+  }
+}

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

@@ -76,6 +76,7 @@ export abstract class CoreUserModel extends CorePersistenceModel {
   /**
    * Verification of the user
    */
+  @Field((type) => Boolean, { description: 'Verification state of the user', nullable: true })
   @Prop({ type: Boolean })
   verified = false;
 

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

@@ -15,6 +15,9 @@ import { CoreUserCreateInput } from './inputs/core-user-create.input';
 import { CoreUserInput } from './inputs/core-user.input';
 import { Model } from 'mongoose';
 import * as _ from 'lodash';
+import * as crypto from 'crypto';
+import envConfig from '../../../config.env';
+import { EmailService } from '../../common/services/email.service';
 
 // Subscription
 const pubSub = new PubSub();
@@ -27,7 +30,7 @@ export abstract class CoreUserService<
   TUserInput extends CoreUserInput,
   TUserCreateInput extends CoreUserCreateInput
 > extends CoreBasicUserService<TUser, TUserInput, TUserCreateInput> {
-  protected constructor(protected readonly userModel: Model<any>) {
+  protected constructor(protected readonly userModel: Model<any>, protected emailService: EmailService) {
     super(userModel);
   }
 
@@ -42,8 +45,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(input));
+    const createdUser = new this.userModel(this.model.map(newUser));
 
     try {
       // Save created user
@@ -115,6 +121,75 @@ export abstract class CoreUserService<
     );
   }
 
+  /**
+   * Verify user with token
+   *
+   * @param token
+   */
+  async verify(token: string): Promise<boolean> {
+    const user = await this.userModel.findOne({ verificationToken: token }).exec();
+
+    if (!user) {
+      throw new NotFoundException();
+    }
+
+    if (!user.verificationToken) {
+      throw new Error('User has no token');
+    }
+
+    if (user.verified) {
+      throw new Error('User already verified');
+    }
+
+    await this.userModel.findByIdAndUpdate(user.id, { $set: { verified: true, verificationToken: null } }).exec();
+
+    return true;
+  }
+
+  /**
+   * Set newpassword for user with token
+   *
+   * @param token
+   * @param newPassword
+   */
+  async resetPassword(token: string, newPassword: string): Promise<boolean> {
+    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();
+
+    return true;
+  }
+
+  /**
+   * Request email with password reset link
+   *
+   * @param email
+   */
+  async requestPasswordResetMail(email: string): Promise<boolean> {
+    const user = await this.userModel.findOne({ email }).exec();
+
+    if (!user) {
+      throw new NotFoundException();
+    }
+
+    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 },
+    });
+
+    return true;
+  }
+
   /**
    * Set roles for specified user
    */
@@ -175,7 +250,7 @@ export abstract class CoreUserService<
   ) {
     // Configuration
     const config = {
-      checkRoles: true,
+      checkRoles: false,
       clone: false,
       ...options,
     };

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

@@ -9,5 +9,5 @@ import { CoreUserInput } from './core-user.input';
 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,54 @@ 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 { CoreModel } from '../../../common/models/core-model.model';
 
 /**
  * User input to update a user
  */
 @InputType({ description: 'User input', isAbstract: true })
-export abstract class CoreUserInput {
+export abstract class CoreUserInput extends CoreModel {
   /**
    * 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[] = [];
 
   /**
    * 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/main.ts

@@ -2,6 +2,7 @@ import { NestFactory } from '@nestjs/core';
 import { NestExpressApplication } from '@nestjs/platform-express';
 import envConfig from './config.env';
 import { ServerModule } from './server/server.module';
+import { MapPipe } from './core/common/pipes/map.pipe';
 
 /**
  * Preparations for server start
@@ -13,6 +14,9 @@ async function bootstrap() {
     ServerModule
   );
 
+  // Add map pipe for mapping inputs to class
+  server.useGlobalPipes(new MapPipe());
+
   // Asset directory
   server.useStaticAssets(envConfig.staticAssets.path, envConfig.staticAssets.options);
 

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

@@ -43,14 +43,6 @@ export class UserResolver {
     return await this.usersService.find(args, info);
   }
 
-  /**
-   * Verify user with email
-   */
-  @Query((returns) => Boolean, { description: 'Verify user with email' })
-  async verifyUser(@Args('token') token: string) {
-    return await this.usersService.verify(token);
-  }
-
   /**
    * Request new password for user with email
    */
@@ -59,17 +51,25 @@ export class UserResolver {
     return await this.usersService.requestPasswordResetMail(email);
   }
 
+  // ===========================================================================
+  // Mutations
+  // ===========================================================================
+  /**
+   * Verify user with email
+   */
+  @Mutation((returns) => Boolean, { description: 'Verify user with email' })
+  async verifyUser(@Args('token') token: string) {
+    return await this.usersService.verify(token);
+  }
+
   /**
    * Set new password for user with token
    */
-  @Query((returns) => Boolean, { description: '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);
   }
 
-  // ===========================================================================
-  // Mutations
-  // ===========================================================================
   /**
    * Create new user
    */
@@ -88,7 +88,7 @@ export class UserResolver {
   @Roles(RoleEnum.ADMIN, RoleEnum.OWNER)
   @Mutation((returns) => User, { description: 'Update existing user' })
   async updateUser(
-    @Args('input') input: UserInput,
+    @Args('input', { type: () => UserInput }) input: UserInput,
     @Args('id') id: string,
     @GraphQLUser() user: User,
     @Info() info: GraphQLResolveInfo

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

@@ -1,10 +1,4 @@
-import {
-  Inject,
-  Injectable,
-  NotFoundException,
-  UnauthorizedException,
-  UnprocessableEntityException,
-} from '@nestjs/common';
+import { Inject, Injectable, UnauthorizedException, UnprocessableEntityException } from '@nestjs/common';
 import * as fs from 'fs';
 import { GraphQLResolveInfo } from 'graphql';
 import envConfig from '../../../config.env';
@@ -21,8 +15,6 @@ import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
 import { ICorePersistenceModel } from '../../../core/common/interfaces/core-persistence-model.interface';
 import { PubSub } from 'graphql-subscriptions';
-import * as crypto from 'crypto';
-import * as bcrypt from 'bcrypt';
 
 /**
  * User service
@@ -50,7 +42,7 @@ export class UserService extends CoreUserService<User, UserInput, UserCreateInpu
     @InjectModel('User') protected readonly userModel: Model<User>,
     @Inject('PUB_SUB') protected readonly pubSub: PubSub
   ) {
-    super(userModel);
+    super(userModel, emailService);
     this.model = User;
   }
 
@@ -68,86 +60,14 @@ export class UserService extends CoreUserService<User, UserInput, UserCreateInpu
 
     await this.pubSub.publish('userCreated', User.map(user));
 
-    const verificationToken = crypto.randomBytes(32).toString('hex');
-    await this.userModel.findByIdAndUpdate(user.id, { $set: { verificationToken } }).exec();
-
     await this.emailService.sendMail(user.email, 'Welcome', {
       htmlTemplate: 'welcome',
-      templateData: { name: user.username, link: envConfig.email.verificationLink + '/' + verificationToken },
+      templateData: { name: user.username, link: envConfig.email.verificationLink + '/' + user.verificationToken },
     });
 
     return user;
   }
 
-  /**
-   * Verify user with token
-   *
-   * @param token
-   */
-  async verify(token: string): Promise<boolean> {
-    const user = await this.userModel.findOne({ verificationToken: token }).exec();
-
-    if (!user) {
-      throw new NotFoundException();
-    }
-
-    if (!user.verificationToken) {
-      throw new Error('User has no token');
-    }
-
-    if (user.verified) {
-      throw new Error('User already verified');
-    }
-
-    await this.userModel.findByIdAndUpdate(user.id, { $set: { verified: true, verificationToken: null } }).exec();
-
-    return true;
-  }
-
-  /**
-   * Set newpassword for user with token
-   *
-   * @param token
-   * @param newPassword
-   */
-  async resetPassword(token: string, newPassword: string): Promise<boolean> {
-    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();
-
-    return true;
-  }
-
-  /**
-   * Request email with password reset link
-   *
-   * @param email
-   */
-  async requestPasswordResetMail(email: string): Promise<boolean> {
-    const user = await this.userModel.findOne({ email }).exec();
-
-    if (!user) {
-      throw new NotFoundException();
-    }
-
-    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 },
-    });
-
-    return true;
-  }
-
   /**
    * Get users via filter
    */