@lenne.tech/nest-server 10.8.9 → 10.8.11

package/src/server/modules/user/outputs/find-and-count-users-result.output.ts

@@ -4,14 +4,14 @@ import { Restricted } from '../../../../core/common/decorators/restricted.decora
 import { RoleEnum } from '../../../../core/common/enums/role.enum';
 import { User } from '../user.model';
 
-@Restricted(RoleEnum.ADMIN)
 @ObjectType({ description: 'Result of find and count' })
+@Restricted(RoleEnum.ADMIN)
 export class FindAndCountUsersResult {
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field(() => [User], { description: 'Found users' })
+  @Restricted(RoleEnum.S_EVERYONE)
   items: User[];
 
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({ description: 'Total count (skip/offset and limit/take are ignored in the count)' })
+  @Restricted(RoleEnum.S_EVERYONE)
   totalCount: number;
 }

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

@@ -13,9 +13,9 @@ export type UserDocument = Document & User;
 /**
  * User model
  */
-@Restricted(RoleEnum.ADMIN)
-@ObjectType({ description: 'User' })
 @MongooseSchema({ timestamps: true })
+@ObjectType({ description: 'User' })
+@Restricted(RoleEnum.ADMIN)
 export class User extends CoreUserModel implements PersistenceModel {
   // ===================================================================================================================
   // Properties
@@ -24,9 +24,9 @@ export class User extends CoreUserModel implements PersistenceModel {
   /**
    * URL to avatar file of the user
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({ description: 'URL to avatar file of the user', nullable: true })
   @Prop()
+  @Restricted(RoleEnum.S_EVERYONE)
   avatar: string = undefined;
 
   /**
@@ -34,30 +34,30 @@ export class User extends CoreUserModel implements PersistenceModel {
    *
    * Not set when created by system
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field(() => String, {
     description: 'ID of the user who created the object',
     nullable: true,
   })
   @Prop({ ref: 'User', type: Schema.Types.ObjectId })
+  @Restricted(RoleEnum.S_EVERYONE)
   createdBy: string = undefined;
 
   /**
    * E-Mail address of the user
    */
-  @Restricted(RoleEnum.S_EVERYONE)
   @Field({ description: 'Email of the user', nullable: true })
   @IsEmail()
   @Prop({ lowercase: true, trim: true, unique: true })
+  @Restricted(RoleEnum.S_EVERYONE)
   override email: string = undefined;
 
   /**
    * Roles of the user
    */
-  @Restricted(RoleEnum.S_EVERYONE)
-  @Field(type => [String], { description: 'Roles of the user', nullable: true })
+  @Field(() => [String], { description: 'Roles of the user', nullable: true })
   @IsOptional()
   @Prop([String])
+  @Restricted(RoleEnum.S_EVERYONE)
   override roles: string[] = undefined;
 
   /**
@@ -65,12 +65,12 @@ export class User extends CoreUserModel implements PersistenceModel {
    *
    * Not set when updated by system
    */
-  @Restricted(RoleEnum.S_USER)
   @Field(() => String, {
     description: 'ID of the user who last updated the object',
     nullable: true,
   })
   @Prop({ ref: 'User', type: Schema.Types.ObjectId })
+  @Restricted(RoleEnum.S_USER)
   updatedBy: string = undefined;
 
   // ===================================================================================================================

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

@@ -7,8 +7,8 @@ import { GraphQLServiceOptions } from '../../../core/common/decorators/graphql-s
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
 import { ServiceOptions } from '../../../core/common/interfaces/service-options.interface';
-import { UserInput } from './inputs/user.input';
 import { UserCreateInput } from './inputs/user-create.input';
+import { UserInput } from './inputs/user.input';
 import { FindAndCountUsersResult } from './outputs/find-and-count-users-result.output';
 import { User } from './user.model';
 import { UserService } from './user.service';
@@ -34,8 +34,8 @@ export class UserResolver {
   /**
    * Get users (via filter)
    */
-  @Roles(RoleEnum.ADMIN)
   @Query(() => [User], { description: 'Find users (via filter)' })
+  @Roles(RoleEnum.ADMIN)
   async findUsers(@GraphQLServiceOptions() serviceOptions: ServiceOptions, @Args() args?: FilterArgs) {
     return await this.userService.find(args, {
       ...serviceOptions,
@@ -46,8 +46,8 @@ export class UserResolver {
   /**
    * Get users and total count (via filter)
    */
-  @Roles(RoleEnum.ADMIN)
   @Query(() => FindAndCountUsersResult, { description: 'Find users (via filter)' })
+  @Roles(RoleEnum.ADMIN)
   async findAndCountUsers(
     @GraphQLServiceOptions({ gqlPath: 'findAndCountUsers.items' }) serviceOptions: ServiceOptions,
     @Args() args?: FilterArgs,
@@ -61,8 +61,8 @@ export class UserResolver {
   /**
    * Get user via ID
    */
-  @Roles(RoleEnum.S_USER)
   @Query(() => User, { description: 'Get user with specified ID' })
+  @Roles(RoleEnum.S_USER)
   async getUser(@GraphQLServiceOptions() serviceOptions: ServiceOptions, @Args('id') id: string): Promise<User> {
     return await this.userService.get(id, {
       ...serviceOptions,
@@ -73,8 +73,8 @@ export class UserResolver {
   /**
    * Get verified state of user with token
    */
-  @Roles(RoleEnum.S_EVERYONE)
   @Query(() => Boolean, { description: 'Get verified state of user with token' })
+  @Roles(RoleEnum.S_EVERYONE)
   async getVerifiedState(@Args('token') token: string) {
     return await this.userService.getVerifiedState(token);
   }
@@ -86,8 +86,8 @@ export class UserResolver {
   /**
    * Create new user
    */
-  @Roles(RoleEnum.ADMIN)
   @Mutation(() => User, { description: 'Create a new user' })
+  @Roles(RoleEnum.ADMIN)
   async createUser(
     @GraphQLServiceOptions() serviceOptions: ServiceOptions,
     @Args('input') input: UserCreateInput,
@@ -101,8 +101,8 @@ export class UserResolver {
   /**
    * Delete existing user
    */
-  @Roles(RoleEnum.S_USER)
   @Mutation(() => User, { description: 'Delete existing user' })
+  @Roles(RoleEnum.S_USER)
   async deleteUser(@GraphQLServiceOptions() serviceOptions: ServiceOptions, @Args('id') id: string): Promise<User> {
     return await this.userService.delete(id, {
       ...serviceOptions,
@@ -113,8 +113,8 @@ export class UserResolver {
   /**
    * Set new password for user with token
    */
-  @Roles(RoleEnum.S_EVERYONE)
   @Mutation(() => Boolean, { description: 'Set new password for user with token' })
+  @Roles(RoleEnum.S_EVERYONE)
   async resetPassword(@Args('token') token: string, @Args('password') password: string): Promise<boolean> {
     return !!(await this.userService.resetPassword(token, password));
   }
@@ -122,8 +122,8 @@ export class UserResolver {
   /**
    * Request new password for user with email
    */
-  @Roles(RoleEnum.S_EVERYONE)
   @Mutation(() => Boolean, { description: 'Request new password for user with email' })
+  @Roles(RoleEnum.S_EVERYONE)
   async requestPasswordResetMail(@Args('email') email: string): Promise<boolean> {
     return !!(await this.userService.sendPasswordResetMail(email));
   }
@@ -131,8 +131,8 @@ export class UserResolver {
   /**
    * Update existing user
    */
-  @Roles(RoleEnum.S_USER)
   @Mutation(() => User, { description: 'Update existing user' })
+  @Roles(RoleEnum.S_USER)
   async updateUser(
     @GraphQLServiceOptions() serviceOptions: ServiceOptions,
     @Args('input') input: UserInput,
@@ -149,8 +149,8 @@ export class UserResolver {
   /**
    * Verify user with email
    */
-  @Roles(RoleEnum.S_EVERYONE)
   @Mutation(() => Boolean, { description: 'Verify user with email' })
+  @Roles(RoleEnum.S_EVERYONE)
   async verifyUser(@Args('token') token: string): Promise<boolean> {
     return !!(await this.userService.verify(token));
   }

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

@@ -8,8 +8,8 @@ import { ConfigService } from '../../../core/common/services/config.service';
 import { EmailService } from '../../../core/common/services/email.service';
 import { CoreModelConstructor } from '../../../core/common/types/core-model-constructor.type';
 import { CoreUserService } from '../../../core/modules/user/core-user.service';
-import { UserInput } from './inputs/user.input';
 import { UserCreateInput } from './inputs/user-create.input';
+import { UserInput } from './inputs/user.input';
 import { User, UserDocument } from './user.model';
 
 import fs = require('fs');

package/src/server/server.controller.ts

@@ -2,14 +2,14 @@ import { Controller, Get, Render } from '@nestjs/common';
 
 import { ConfigService, RoleEnum, Roles } from '..';
 
-@Roles(RoleEnum.ADMIN)
 @Controller()
+@Roles(RoleEnum.ADMIN)
 export class ServerController {
   constructor(protected configService: ConfigService) {}
 
-  @Roles(RoleEnum.S_EVERYONE)
   @Get()
   @Render('index')
+  @Roles(RoleEnum.S_EVERYONE)
   root() {
     return {
       env: this.configService.getFastButReadOnly('env'),

package/src/test/test.helper.ts

@@ -23,13 +23,18 @@ export enum TestGraphQLType {
  * GraphQL fields
  */
 export interface TestFieldObject {
-  [key: string]: (TestFieldObject | string)[] | TestFieldObject | boolean;
+  [key: string]: (string | TestFieldObject)[] | boolean | TestFieldObject;
 }
 
 /**
  * GraphQL fields
  */
-export type TestFields = TestFieldObject | string | string[];
+export type TestFields = string | string[] | TestFieldObject;
+
+export interface TestGraphQLAttachment {
+  file: Blob | boolean | Buffer | number | ReadableStream | string;
+  options?: string | { contentType?: string | undefined; filename?: string | undefined };
+}
 
 /**
  * GraphQL request config
@@ -64,16 +69,6 @@ export interface TestGraphQLConfig {
   variables?: Record<string, string>;
 }
 
-export interface TestGraphQLAttachment {
-  file: Blob | Buffer | ReadableStream | boolean | number | string;
-  options?: { contentType?: string | undefined; filename?: string | undefined } | string;
-}
-
-export interface TestGraphQLVariable {
-  type: 'attachment' | 'field';
-  value: TestGraphQLAttachment | TestGraphQLAttachment[] | any | string | string[];
-}
-
 /**
  * Options for graphql requests
  */
@@ -120,6 +115,11 @@ export interface TestGraphQLOptions {
   variables?: Record<string, TestGraphQLVariable>;
 }
 
+export interface TestGraphQLVariable {
+  type: 'attachment' | 'field';
+  value: any | string | string[] | TestGraphQLAttachment | TestGraphQLAttachment[];
+}
+
 /**
  * Options for rest requests
  */
@@ -178,7 +178,7 @@ export class TestHelper {
           });
         })
         .end((err, res: any) => {
-          (res as { data: string } & any).data = Buffer.from(data, 'binary').toString();
+          (res as any & { data: string }).data = Buffer.from(data, 'binary').toString();
           err ? reject(err) : resolve(res as any);
         });
     });
@@ -221,7 +221,7 @@ export class TestHelper {
   /**
    * GraphQL request
    */
-  async graphQl(graphql: TestGraphQLConfig | string, options: TestGraphQLOptions = {}): Promise<any> {
+  async graphQl(graphql: string | TestGraphQLConfig, options: TestGraphQLOptions = {}): Promise<any> {
     // Default options
     const config = {
       convertEnums: true,
@@ -303,12 +303,26 @@ export class TestHelper {
     if (config.convertEnums) {
       if (Array.isArray(config.convertEnums)) {
         for (const key of Object.values(config.convertEnums)) {
-          const regExpStr = `(${key}: )\\"([_A-Z][_0-9A-Z]*)\\"`;
+          const regExpStr = `(?<=${key}:\\s*)"([A-Z0-9_]+)"(?=\\s*[,\\]}])`;
           const regExp = new RegExp(regExpStr, 'g');
-          query = query.replace(regExp, '$1$2');
+          query = query.replace(regExp, (match, group1) => {
+            // If group1 consists exclusively of digits, return original string
+            if (/^\d+$/.test(group1)) {
+              return match;
+            }
+            // Otherwise remove quotation marks
+            return group1;
+          });
         }
       } else {
-        query = query.replace(/([_A-Za-z][_0-9A-Za-z]*:\s)\"([_A-Z][_0-9A-Z]*)\"/g, '$1$2');
+        query = query.replace(/(?<=[:\[,]\s*)"([A-Z0-9_]+)"(?=\s*[,\]\}])/g, (match, group1) => {
+          // If group1 only contains digits, the original string is returned
+          if (/^\d+$/.test(group1)) {
+            return match;
+          }
+          // Otherwise the quotation marks are removed
+          return group1;
+        });
       }
     }