@lenne.tech/nest-server 8.0.0 → 8.1.0

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

@@ -1,20 +1,15 @@
 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 { Filter } from '../../common/helpers/filter.helper';
-import { ServiceHelper } from '../../common/helpers/service.helper';
-import { CoreBasicUserService } from './core-basic-user.service';
+import * as crypto from 'crypto';
+import { Document, Model } from 'mongoose';
+import { merge } from '../../common/helpers/config.helper';
+import { ServiceOptions } from '../../common/interfaces/service-options.interface';
+import { CrudService } from '../../common/services/crud.service';
+import { EmailService } from '../../common/services/email.service';
+import { CoreModelConstructor } from '../../common/types/core-model-constructor.type';
 import { CoreUserModel } from './core-user.model';
 import { CoreUserCreateInput } from './inputs/core-user-create.input';
 import { CoreUserInput } from './inputs/core-user.input';
-import { Model, Document } from 'mongoose';
-import * as crypto from 'crypto';
-import envConfig from '../../../config.env';
-import { EmailService } from '../../common/services/email.service';
-
-// Subscription
-const pubSub = new PubSub();
 
 /**
  * User service
@@ -23,9 +18,13 @@ export abstract class CoreUserService<
   TUser extends CoreUserModel,
   TUserInput extends CoreUserInput,
   TUserCreateInput extends CoreUserCreateInput
-> extends CoreBasicUserService<TUser, TUserInput, TUserCreateInput> {
-  protected constructor(protected readonly userModel: Model<TUser & Document>, protected emailService: EmailService) {
-    super(userModel);
+> extends CrudService<TUser> {
+  protected constructor(
+    protected emailService: EmailService,
+    protected readonly mainDbModel: Model<TUser & Document>,
+    protected mainModelConstructor: CoreModelConstructor<TUser>
+  ) {
+    super();
   }
 
   // ===================================================================================================================
@@ -35,167 +34,149 @@ export abstract class CoreUserService<
   /**
    * Create user
    */
-  async create(input: TUserCreateInput, currentUser?: TUser, ...args: any[]): Promise<TUser> {
-    // Prepare input
-    await this.prepareInput(input, currentUser, { create: true });
-
-    // Create new user
-    const createdUser = new this.userModel({
-      ...input,
-      verificationToken: crypto.randomBytes(32).toString('hex'),
-    });
-
-    try {
-      // Save created user
-      await createdUser.save();
-    } catch (error) {
-      if (error.code === 11000) {
-        throw new UnprocessableEntityException(`User with email address "${(input as any).email}" already exists`);
-      } else {
-        throw new UnprocessableEntityException();
-      }
-    }
-
-    // Prepare output
-    const preparedUser = await this.prepareOutput(this.model.map(createdUser), args[0]);
-
-    // Inform subscriber
-    pubSub.publish('userCreated', { userCreated: preparedUser });
-
-    // Return created user
-    return preparedUser;
+  async create(input: any, serviceOptions?: ServiceOptions): Promise<TUser> {
+    merge({ prepareInput: { create: true } }, serviceOptions);
+    return this.process(
+      async (data) => {
+        // Create user with verification token
+        const createdUser = new this.mainDbModel({
+          ...data.input,
+          verificationToken: crypto.randomBytes(32).toString('hex'),
+        });
+
+        // Distinguish between different error messages when saving
+        try {
+          await createdUser.save();
+        } catch (error) {
+          if (error.code === 11000) {
+            throw new UnprocessableEntityException(
+              `User with email address "${(data.input as any).email}" already exists`
+            );
+          } else {
+            throw new UnprocessableEntityException();
+          }
+        }
+
+        // Return created user
+        return createdUser;
+      },
+      { input, serviceOptions }
+    );
   }
 
   /**
-   * Delete user via ID
+   * Get user via email
    */
-  async delete(id: string, ...args: any[]): Promise<TUser> {
-    // Search user
-    const user = await this.userModel.findById(id).exec();
-
-    // Check user
-    if (!user) {
-      throw new NotFoundException();
-    }
-
-    // Delete user
-    await user.delete();
-
-    // Prepare output
-    const deletedUser = await this.prepareOutput(this.model.map(user), args[0]);
-
-    // Inform subscriber
-    pubSub.publish('userDeleted', { userDeleted: deletedUser });
-
-    // Return deleted user
-    return deletedUser;
+  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 }
+    );
   }
 
   /**
-   * Get user via ID
+   * Get verified state of user by token
    */
-  async get(id: string, ...args: any[]): Promise<TUser> {
-    const user = await this.userModel.findById(id).exec();
+  async getVerifiedState(token: string, serviceOptions?: ServiceOptions): Promise<boolean> {
+    const user = await this.mainDbModel.findOne({ verificationToken: token }).exec();
 
     if (!user) {
-      throw new NotFoundException();
+      throw new NotFoundException(`No user found with verify token: ${token}`);
     }
 
-    return this.prepareOutput(this.model.map(user), args[0]);
-  }
-
-  /**
-   * Get users via filter
-   */
-  async find(filterArgs?: FilterArgs, ...args: any[]): Promise<TUser[]> {
-    const filterQuery = Filter.convertFilterArgsToQuery(filterArgs);
-    // Return found users
-    return await Promise.all(
-      (
-        await this.userModel.find(filterQuery[0], null, filterQuery[1]).exec()
-      ).map((user) => {
-        return this.prepareOutput(this.model.map(user), args[0]);
-      })
-    );
+    return user.verified;
   }
 
   /**
    * Verify user with token
    */
-  async verify(token: string, ...args: any[]): Promise<TUser> {
-    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');
-    }
-
-    // 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 prepared verified user
-    return verifiedUser;
+  async verify(token: string, serviceOptions?: ServiceOptions): Promise<TUser> {
+    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, {
+          verified: true,
+          verificationToken: null,
+        }).save();
+
+        // Return prepared user
+        return user;
+      },
+      { serviceOptions }
+    );
   }
 
   /**
    * Set newpassword for user with token
    */
-  async resetPassword(token: string, newPassword: string, ...args: any[]): Promise<TUser> {
-    const user = await this.userModel.findOne({ passwordResetToken: token }).exec();
-
-    if (!user) {
-      throw new NotFoundException();
-    }
-
-    // Update user
-    await Object.assign(user, {
-      password: await bcrypt.hash(newPassword, 10),
-      passwordResetToken: null,
-    }).save();
-
-    // Return prepared user with changed password
-    return this.prepareOutput(this.model.map(user), args[0]);
+  async resetPassword(token: string, newPassword: string, serviceOptions?: ServiceOptions): Promise<TUser> {
+    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, {
+          password: await bcrypt.hash(newPassword, 10),
+          passwordResetToken: null,
+        }).save();
+
+        // Return user
+        return user;
+      },
+      { serviceOptions }
+    );
   }
 
   /**
    * Set password rest token for email
    */
-  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');
-    user.passwordResetToken = resetToken;
-    await user.save();
-
-    // Return user who want to reset the password
-    return this.prepareOutput(this.model.map(user), args[0]);
+  async setPasswordResetTokenForEmail(email: string, serviceOptions?: ServiceOptions): Promise<TUser> {
+    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();
+
+        // Return user
+        return user;
+      },
+      { serviceOptions }
+    );
   }
 
   /**
    * Set roles for specified user
    */
-  async setRoles(userId: string, roles: string[], ...args: any[]): Promise<TUser> {
+  async setRoles(userId: string, roles: string[], serviceOptions?: ServiceOptions): Promise<TUser> {
     // Check roles
     if (!Array.isArray(roles)) {
       throw new BadRequestException('Missing roles');
@@ -207,55 +188,11 @@ export abstract class CoreUserService<
     }
 
     // Update and return user
-    const user = await this.userModel.findByIdAndUpdate(userId, { roles }).exec();
-    return this.prepareOutput(this.model.map(user), args[0]);
-  }
-
-  /**
-   * Update user via ID
-   */
-  async update(id: string, input: TUserInput, currentUser: TUser, ...args: any[]): Promise<TUser> {
-    // Check if user exists
-    const user = await this.userModel.findById(id).exec();
-
-    if (!user) {
-      throw new NotFoundException(`User not found with ID: ${id}`);
-    }
-
-    // Prepare input
-    await this.prepareInput(input, currentUser);
-
-    // Update
-    await Object.assign(user, input).save();
-
-    // Return user
-    return await this.prepareOutput(this.model.map(user), args[0]);
-  }
-
-  // ===================================================================================================================
-  // Helper methods
-  // ===================================================================================================================
-
-  /**
-   * Prepare input before save
-   */
-  protected async prepareInput(
-    input: Record<string, any>,
-    currentUser?: TUser,
-    options: { [key: string]: any; checkRoles?: boolean; clone?: boolean } = {},
-    ...args: any[]
-  ) {
-    return ServiceHelper.prepareInput(input, currentUser, options);
-  }
-
-  /**
-   * Prepare output before return
-   */
-  protected async prepareOutput(
-    user: TUser,
-    options: { [key: string]: any; clone?: boolean } = {},
-    ...args: any[]
-  ): Promise<TUser> {
-    return ServiceHelper.prepareOutput(user, options);
+    return this.process(
+      async (data) => {
+        return await this.mainDbModel.findByIdAndUpdate(userId, { roles }).exec();
+      },
+      { serviceOptions }
+    );
   }
 }

package/src/core.module.ts

@@ -1,7 +1,7 @@
 import { DynamicModule, Global, Module, UnauthorizedException } 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 { merge } 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 { MapAndValidatePipe } from './core/common/pipes/map-and-validate.pipe';
@@ -36,39 +36,43 @@ export class CoreModule {
    */
   static forRoot(AuthService: any, AuthModule: any, options: Partial<IServerOptions>): DynamicModule {
     // Process config
-    const config: IServerOptions = Config.merge(
+    const config: IServerOptions = merge(
       {
         env: 'develop',
         graphQl: {
           driver: {
             imports: [AuthModule],
             inject: [AuthService],
-            useFactory: async (authService: any) => ({
-              autoSchemaFile: 'schema.gql',
-              context: ({ req }) => ({ req }),
-              installSubscriptionHandlers: true,
-              subscriptions: {
-                'subscriptions-transport-ws': {
-                  onConnect: async (connectionParams) => {
-                    if (config.graphQl.enableSubscriptionAuth) {
-                      // get authToken from authorization header
-                      const authToken: string =
-                        'Authorization' in connectionParams && connectionParams?.Authorization?.split(' ')[1];
+            useFactory: async (authService: any) =>
+              Object.assign(
+                {
+                  autoSchemaFile: 'schema.gql',
+                  context: ({ req }) => ({ req }),
+                  installSubscriptionHandlers: true,
+                  subscriptions: {
+                    'subscriptions-transport-ws': {
+                      onConnect: async (connectionParams) => {
+                        if (config.graphQl.enableSubscriptionAuth) {
+                          // get authToken from authorization header
+                          const authToken: string =
+                            'Authorization' in connectionParams && connectionParams?.Authorization?.split(' ')[1];
 
-                      if (authToken) {
-                        // verify authToken/getJwtPayLoad
-                        const payload = authService.decodeJwt(authToken);
-                        const user = await authService.validateUser(payload);
-                        // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
-                        return { user: user, headers: connectionParams };
-                      }
+                          if (authToken) {
+                            // verify authToken/getJwtPayLoad
+                            const payload = authService.decodeJwt(authToken);
+                            const user = await authService.validateUser(payload);
+                            // the user/jwtPayload object found will be available as context.currentUser/jwtPayload in your GraphQL resolvers
+                            return { user: user, headers: connectionParams };
+                          }
 
-                      throw new UnauthorizedException();
-                    }
+                          throw new UnauthorizedException();
+                        }
+                      },
+                    },
                   },
                 },
-              },
-            }),
+                options?.graphQl?.driver
+              ),
           },
           enableSubscriptionAuth: true,
         },

package/src/index.ts

@@ -19,6 +19,7 @@ export * from './core/common/enums/role.enum';
 export * from './core/common/enums/sort-order.emum';
 export * from './core/common/helpers/config.helper';
 export * from './core/common/helpers/context.helper';
+export * from './core/common/helpers/db.helper';
 export * from './core/common/helpers/file.helper';
 export * from './core/common/helpers/filter.helper';
 export * from './core/common/helpers/graphql.helper';
@@ -33,7 +34,9 @@ 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/resolve-selector.interface';
 export * from './core/common/interfaces/server-options.interface';
+export * from './core/common/interfaces/service-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';
@@ -42,10 +45,15 @@ 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/crud.service';
 export * from './core/common/services/email.service';
 export * from './core/common/services/mailjet.service';
+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/plain-input.type';
+export * from './core/common/types/string-or-object-id.type';
 
 // =====================================================================================================================
 // Core - Modules - Auth
@@ -68,7 +76,6 @@ 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-basic-user.service';
 export * from './core/modules/user/core-user.model';
 export * from './core/modules/user/core-user.service';
 

package/src/main.ts

@@ -7,7 +7,7 @@ import { ServerModule } from './server/server.module';
  * Preparations for server start
  */
 async function bootstrap() {
-  // Create a new server based on fastify
+  // Create a new server based on express
   const server = await NestFactory.create<NestExpressApplication>(
     // Include server module, with all necessary modules for the project
     ServerModule

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

@@ -1,4 +1,5 @@
-import { Args, Query, Resolver } from '@nestjs/graphql';
+import { Args, Info, Query, Resolver } from '@nestjs/graphql';
+import { GraphQLResolveInfo } from 'graphql';
 import { CoreAuthResolver } from '../../../core/modules/auth/core-auth.resolver';
 import { Auth } from './auth.model';
 
@@ -11,7 +12,11 @@ export class AuthResolver extends CoreAuthResolver {
    * Get user via ID
    */
   @Query((returns) => Auth, { description: 'Get JWT token' })
-  async signIn(@Args('email') email: string, @Args('password') password: string): Promise<Auth> {
-    return (await this.authService.signIn(email, password)) as Auth;
+  async signIn(
+    @Args('email') email: string,
+    @Args('password') password: string,
+    @Info() info: GraphQLResolveInfo
+  ): Promise<Auth> {
+    return (await this.authService.signIn(email, password, { fieldSelection: { info, select: 'signIn' } })) as Auth;
   }
 }

package/src/server/modules/file/file.controller.ts

@@ -4,7 +4,7 @@ import { diskStorage } from 'multer';
 import envConfig from '../../../config.env';
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
-import { FileHelper } from '../../../core/common/helpers/file.helper';
+import { multerRandomFileName } from '../../../core/common/helpers/file.helper';
 
 /**
  * File controller for
@@ -27,7 +27,7 @@ export class FileController {
         destination: envConfig.staticAssets.path,
 
         // Generated random file name
-        filename: FileHelper.multerRandomFileName(),
+        filename: multerRandomFileName(),
       }),
     })
   )

package/src/server/modules/user/avatar.controller.ts

@@ -5,7 +5,7 @@ import envConfig from '../../../config.env';
 import { RESTUser } from '../../../core/common/decorators/rest-user.decorator';
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
-import { FileHelper } from '../../../core/common/helpers/file.helper';
+import { multerOptionsForImageUpload } from '../../../core/common/helpers/file.helper';
 import { User } from './user.model';
 import { UserService } from './user.service';
 
@@ -27,7 +27,7 @@ export class AvatarController {
   @UseInterceptors(
     FileInterceptor(
       'file',
-      FileHelper.multerOptionsForImageUpload({
+      multerOptionsForImageUpload({
         destination: envConfig.staticAssets.path + '/avatars',
       })
     )

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

@@ -1,11 +1,11 @@
 import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { PubSub } from 'graphql-subscriptions';
 import { JSON } from '../../../core/common/scalars/json.scalar';
 import { AvatarController } from './avatar.controller';
 import { User, UserSchema } from './user.model';
 import { UserResolver } from './user.resolver';
 import { UserService } from './user.service';
-import { MongooseModule } from '@nestjs/mongoose';
-import { PubSub } from 'graphql-subscriptions';
 
 /**
  * User module
@@ -17,11 +17,15 @@ import { PubSub } from 'graphql-subscriptions';
     JSON,
     UserResolver,
     UserService,
+    {
+      provide: 'USER_CLASS',
+      useValue: User,
+    },
     {
       provide: 'PUB_SUB',
       useValue: new PubSub(),
     },
   ],
-  exports: [MongooseModule, UserResolver, UserService],
+  exports: [MongooseModule, UserResolver, UserService, 'USER_CLASS'],
 })
 export class UserModule {}