@lenne.tech/nest-server 8.1.0 → 8.2.0

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

@@ -47,6 +47,11 @@ export abstract class CoreUserService<
         // Distinguish between different error messages when saving
         try {
           await createdUser.save();
+          if (!createdUser.ownerIds) {
+            createdUser.ownerIds = [];
+          }
+          createdUser.ownerIds.push(createdUser.id);
+          await createdUser.save();
         } catch (error) {
           if (error.code === 11000) {
             throw new UnprocessableEntityException(
@@ -68,16 +73,11 @@ export abstract class CoreUserService<
    * Get user via email
    */
   async getViaEmail(email: string, serviceOptions?: ServiceOptions): Promise<TUser> {
-    return this.process(
-      async () => {
-        const user = await this.mainDbModel.findOne({ email }).exec();
-        if (!user) {
-          throw new NotFoundException(`No user found with email: ${email}`);
-        }
-        return user;
-      },
-      { serviceOptions }
-    );
+    const dbObject = await this.mainDbModel.findOne({ email }).exec();
+    if (!dbObject) {
+      throw new NotFoundException(`No user found with email: ${email}`);
+    }
+    return this.process(async () => dbObject, { dbObject, serviceOptions });
   }
 
   /**
@@ -97,30 +97,29 @@ export abstract class CoreUserService<
    * Verify user with token
    */
   async verify(token: string, serviceOptions?: ServiceOptions): Promise<TUser> {
+    // Get user
+    const dbObject = await this.mainDbModel.findOne({ verificationToken: token }).exec();
+    if (!dbObject) {
+      throw new NotFoundException(`No user found with verify token: ${token}`);
+    }
+    if (!dbObject.verificationToken) {
+      throw new Error('User has no token');
+    }
+    if (dbObject.verified) {
+      throw new Error('User already verified');
+    }
     return this.process(
       async () => {
-        // Get user
-        const user = await this.mainDbModel.findOne({ verificationToken: token }).exec();
-        if (!user) {
-          throw new NotFoundException(`No user found with verify token: ${token}`);
-        }
-        if (!user.verificationToken) {
-          throw new Error('User has no token');
-        }
-        if (user.verified) {
-          throw new Error('User already verified');
-        }
-
         // Update user
-        await Object.assign(user, {
+        await Object.assign(dbObject, {
           verified: true,
           verificationToken: null,
         }).save();
 
         // Return prepared user
-        return user;
+        return dbObject;
       },
-      { serviceOptions }
+      { dbObject, serviceOptions }
     );
   }
 
@@ -128,24 +127,24 @@ export abstract class CoreUserService<
    * Set newpassword for user with token
    */
   async resetPassword(token: string, newPassword: string, serviceOptions?: ServiceOptions): Promise<TUser> {
+    // Get user
+    const dbObject = await this.mainDbModel.findOne({ passwordResetToken: token }).exec();
+    if (!dbObject) {
+      throw new NotFoundException(`No user found with password reset token: ${token}`);
+    }
+
     return this.process(
       async () => {
-        // Get user
-        const user = await this.mainDbModel.findOne({ passwordResetToken: token }).exec();
-        if (!user) {
-          throw new NotFoundException(`No user found with password reset token: ${token}`);
-        }
-
         // Update user
-        await Object.assign(user, {
+        await Object.assign(dbObject, {
           password: await bcrypt.hash(newPassword, 10),
           passwordResetToken: null,
         }).save();
 
         // Return user
-        return user;
+        return dbObject;
       },
-      { serviceOptions }
+      { dbObject, serviceOptions }
     );
   }
 
@@ -153,23 +152,22 @@ export abstract class CoreUserService<
    * Set password rest token for email
    */
   async setPasswordResetTokenForEmail(email: string, serviceOptions?: ServiceOptions): Promise<TUser> {
+    // Get user
+    const dbObject = await this.mainDbModel.findOne({ email }).exec();
+    if (!dbObject) {
+      throw new NotFoundException(`No user found with email: ${email}`);
+    }
     return this.process(
       async () => {
-        // Get user
-        const user = await this.mainDbModel.findOne({ email }).exec();
-        if (!user) {
-          throw new NotFoundException(`No user found with email: ${email}`);
-        }
-
         // Set reset token
         const resetToken = crypto.randomBytes(32).toString('hex');
-        user.passwordResetToken = resetToken;
-        await user.save();
+        dbObject.passwordResetToken = resetToken;
+        await dbObject.save();
 
         // Return user
-        return user;
+        return dbObject;
       },
-      { serviceOptions }
+      { dbObject, serviceOptions }
     );
   }
 

package/src/index.ts

@@ -52,6 +52,7 @@ export * from './core/common/services/module.service';
 export * from './core/common/services/template.service';
 export * from './core/common/types/core-model-constructor.type';
 export * from './core/common/types/field-selection.type';
+export * from './core/common/types/ids.type';
 export * from './core/common/types/plain-input.type';
 export * from './core/common/types/string-or-object-id.type';
 

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

@@ -6,7 +6,6 @@ import { FilterArgs } from '../../../core/common/args/filter.args';
 import { GraphQLUser } from '../../../core/common/decorators/graphql-user.decorator';
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
-import { check } from '../../../core/common/helpers/input.helper';
 import { UserCreateInput } from './inputs/user-create.input';
 import { UserInput } from './inputs/user.input';
 import { User } from './user.model';
@@ -32,16 +31,23 @@ export class UserResolver {
   @Roles(RoleEnum.ADMIN)
   @Query((returns) => [User], { description: 'Find users (via filter)' })
   async findUsers(@Info() info: GraphQLResolveInfo, @Args() args?: FilterArgs) {
-    return await this.userService.find(args, { fieldSelection: { info, select: 'findUsers' } });
+    return await this.userService.find(args, {
+      fieldSelection: { info, select: 'findUsers' },
+      inputType: FilterArgs,
+    });
   }
 
   /**
    * Get user via ID
    */
-  @Roles(RoleEnum.OWNER, RoleEnum.ADMIN)
+  @Roles(RoleEnum.USER)
   @Query((returns) => User, { description: 'Get user with specified ID' })
-  async getUser(@Args('id') id: string, @Info() info: GraphQLResolveInfo): Promise<User> {
-    return await this.userService.get(id, { fieldSelection: { info, select: 'getUser' } });
+  async getUser(@Args('id') id: string, @Info() info: GraphQLResolveInfo, @GraphQLUser() user: User): Promise<User> {
+    return await this.userService.get(id, {
+      currentUser: user,
+      fieldSelection: { info, select: 'getUser' },
+      roles: [RoleEnum.OWNER, RoleEnum.ADMIN],
+    });
   }
 
   /**
@@ -73,21 +79,24 @@ export class UserResolver {
     @GraphQLUser() user: User,
     @Info() info: GraphQLResolveInfo
   ): 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 check(input, user, UserCreateInput);
-
-    return await this.userService.create(input, { currentUser: user, fieldSelection: { info, select: 'createUser' } });
+    return await this.userService.create(input, {
+      currentUser: user,
+      fieldSelection: { info, select: 'createUser' },
+      inputType: UserCreateInput,
+    });
   }
 
   /**
    * Delete existing user
    */
-  @Roles(RoleEnum.ADMIN, RoleEnum.OWNER)
+  @Roles(RoleEnum.USER)
   @Mutation((returns) => User, { description: 'Delete existing user' })
-  async deleteUser(@Args('id') id: string, @Info() info: GraphQLResolveInfo): Promise<User> {
-    return await this.userService.delete(id, { fieldSelection: { info, select: 'deleteUser' } });
+  async deleteUser(@Args('id') id: string, @Info() info: GraphQLResolveInfo, @GraphQLUser() user: User): Promise<User> {
+    return await this.userService.delete(id, {
+      currentUser: user,
+      fieldSelection: { info, select: 'deleteUser' },
+      roles: [RoleEnum.ADMIN, RoleEnum.OWNER],
+    });
   }
 
   /**
@@ -101,7 +110,7 @@ export class UserResolver {
   /**
    * Update existing user
    */
-  @Roles(RoleEnum.ADMIN, RoleEnum.OWNER)
+  @Roles(RoleEnum.USER)
   @Mutation((returns) => User, { description: 'Update existing user' })
   async updateUser(
     @Args('input') input: UserInput,
@@ -109,15 +118,12 @@ export class UserResolver {
     @GraphQLUser() user: User,
     @Info() info: GraphQLResolveInfo
   ): 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 check(input, user, UserInput);
-
     // Update user
     return await this.userService.update(id, input, {
       currentUser: user,
       fieldSelection: { info, select: 'updateUser' },
+      inputType: UserInput,
+      roles: [RoleEnum.ADMIN, RoleEnum.OWNER],
     });
   }