@lenne.tech/nest-server 11.0.1 → 11.1.0

package/src/core/common/inputs/single-filter.input.ts

@@ -1,6 +1,7 @@
-import { Field, InputType } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
 
 import { Restricted } from '../decorators/restricted.decorator';
+import { UnifiedField } from '../decorators/unified-field.decorator';
 import { ComparisonOperatorEnum } from '../enums/comparison-operator.enum';
 import { RoleEnum } from '../enums/role.enum';
 import { JSON } from '../scalars/json.scalar';
@@ -15,63 +16,71 @@ export class SingleFilterInput extends CoreInput {
   /**
    * Convert value to ObjectId
    */
-  @Field({
+
+  @UnifiedField({
     description: 'Convert value to ObjectId',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   convertToObjectId?: boolean = undefined;
 
   /**
    * Name of the property to be used for the filter
    */
-  @Field({ description: 'Name of the property to be used for the filter' })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Name of the property to be used for the filter',
+    roles: RoleEnum.S_EVERYONE,
+  })
   field: string = undefined;
 
   /**
    * Process value as reference
    */
-  @Field({
+  @UnifiedField({
     description: 'Process value as reference',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   isReference?: boolean = undefined;
 
   /**
    * [Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)
    */
-  @Field({
+  @UnifiedField({
     description: '[Negate operator](https://docs.mongodb.com/manual/reference/operator/query/not/)',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   not?: boolean = undefined;
 
   /**
    * [Comparison operator](https://docs.mongodb.com/manual/reference/operator/query-comparison/)
    */
-  @Field(() => ComparisonOperatorEnum, {
+  @UnifiedField({
     description: '[Comparison operator](https://docs.mongodb.com/manual/reference/operator/query-comparison/)',
+    enum: { enum: ComparisonOperatorEnum },
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   operator: ComparisonOperatorEnum = undefined;
 
   /**
    * [Options](https://docs.mongodb.com/manual/reference/operator/query/regex/#op._S_options) for
    * [REGEX](https://docs.mongodb.com/manual/reference/operator/query/regex/) operator
    */
-  @Field({
+  @UnifiedField({
     description:
       '[Options](https://docs.mongodb.com/manual/reference/operator/query/regex/#op._S_options) for '
       + '[REGEX](https://docs.mongodb.com/manual/reference/operator/query/regex/) operator',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   options?: string = undefined;
 
-  @Field(() => JSON, { description: 'Value of the property' })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Value of the property',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    type: () => JSON,
+  })
   value: any = undefined;
 }

package/src/core/common/inputs/sort.input.ts

@@ -1,6 +1,7 @@
-import { Field, InputType } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
 
 import { Restricted } from '../decorators/restricted.decorator';
+import { UnifiedField } from '../decorators/unified-field.decorator';
 import { RoleEnum } from '../enums/role.enum';
 import { SortOrderEnum } from '../enums/sort-order.emum';
 import { CoreInput } from './core-input.input';
@@ -14,14 +15,19 @@ export class SortInput extends CoreInput {
   /**
    * Field that is to be used for sorting
    */
-  @Field({ description: 'Field that is to be used for sorting' })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Field that is to be used for sorting',
+    roles: RoleEnum.S_EVERYONE,
+  })
   field: string = undefined;
 
   /**
    * SortInput order of the field
    */
-  @Field(() => SortOrderEnum, { description: 'SortInput order of the field' })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'SortInput order of the field',
+    enum: { enum: SortOrderEnum },
+    roles: RoleEnum.S_EVERYONE,
+  })
   order: SortOrderEnum = undefined;
 }

package/src/core/common/models/core-persistence.model.ts

@@ -1,9 +1,9 @@
-import { Field, ID, ObjectType } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
 import { Prop, Schema } from '@nestjs/mongoose';
-import { ApiProperty } from '@nestjs/swagger';
 import { Types } from 'mongoose';
 
 import { Restricted } from '../decorators/restricted.decorator';
+import { UnifiedField } from '../decorators/unified-field.decorator';
 import { RoleEnum } from '../enums/role.enum';
 import { getStringIds } from '../helpers/db.helper';
 import { CoreModel } from './core-model.model';
@@ -43,30 +43,37 @@ export abstract class CorePersistenceModel extends CoreModel {
   /**
    * ID of the persistence object as string
    */
-  @ApiProperty({ type: String })
-  @Field(() => ID, {
+  @UnifiedField({
     description: 'ID of the persistence object',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   id: string = undefined;
 
   /**
    * Created date, is set automatically by mongoose
    */
-  @ApiProperty({ example: 1740037703939, format: 'int64', type: Date })
-  @Field({ description: 'Created date', nullable: true })
   @Prop({ onCreate: () => new Date() })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Created date',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    swaggerApiOptions: { example: 1740037703939, format: 'int64', type: Date },
+    type: Date,
+  })
   createdAt: Date = undefined;
 
   /**
    * Updated date is set automatically by mongoose
    */
-  @ApiProperty({ example: 1740037703939, format: 'int64', type: String })
-  @Field({ description: 'Updated date', nullable: true })
   @Prop({ onUpdate: () => new Date() })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Updated date',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    swaggerApiOptions: { example: 1740037703939, format: 'int64', type: Date },
+    type: Date,
+  })
   updatedAt: Date = undefined;
 
   // ===========================================================================

package/src/core/common/pipes/map-and-validate.pipe.ts

@@ -1,6 +1,6 @@
 import { ArgumentMetadata, BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
 import { plainToInstance } from 'class-transformer';
-import { validate } from 'class-validator';
+import { validate, ValidationError } from 'class-validator';
 
 import { isBasicType } from '../helpers/input.helper';
 
@@ -26,9 +26,20 @@ export class MapAndValidatePipe implements PipeTransform {
     const errors = await validate(value, { forbidUnknownValues: false });
     if (errors.length > 0) {
       const result = {};
-      errors.forEach((e) => {
-        result[e.property] = e.constraints;
-      });
+
+      const processErrors = (errorList: ValidationError[], parentKey = '') => {
+        errorList.forEach((e) => {
+          const key = parentKey ? `${parentKey}.${e.property}` : e.property;
+
+          if (e.children && e.children.length > 0) {
+            processErrors(e.children, key);
+          } else {
+            result[key] = e.constraints;
+          }
+        });
+      };
+
+      processErrors(errors);
       throw new BadRequestException(result);
     }
 

package/src/core/common/services/brevo.service.ts

@@ -1,9 +1,8 @@
+import brevo = require('@getbrevo/brevo');
 import { Injectable } from '@nestjs/common';
 
 import { ConfigService } from './config.service';
 
-import brevo = require('@getbrevo/brevo');
-
 /**
  * Brevo service to send transactional emails
  */

package/src/core/common/services/config.service.ts

@@ -1,4 +1,5 @@
 import { cloneDeep } from 'lodash';
+import _ = require('lodash');
 import { BehaviorSubject, firstValueFrom } from 'rxjs';
 import { filter, map } from 'rxjs/operators';
 
@@ -6,8 +7,6 @@ import { merge } from '../helpers/config.helper';
 import { clone, deepFreeze } from '../helpers/input.helper';
 import { IServerOptions } from '../interfaces/server-options.interface';
 
-import _ = require('lodash');
-
 /**
  * Config service can be used as provider (after initialization in CoreModule.forRoot)
  *

package/src/core/common/services/email.service.ts

@@ -1,12 +1,11 @@
 import { Injectable } from '@nestjs/common';
+import nodemailer = require('nodemailer');
 import { Attachment } from 'nodemailer/lib/mailer';
 
 import { isNonEmptyString, isTrue, returnFalse } from '../helpers/input.helper';
 import { ConfigService } from './config.service';
 import { TemplateService } from './template.service';
 
-import nodemailer = require('nodemailer');
-
 /**
  * Email service
  */

package/src/core/common/services/model-doc.service.ts

@@ -1,8 +1,7 @@
 import { Injectable, OnApplicationBootstrap } from '@nestjs/common';
 import { InjectConnection } from '@nestjs/mongoose';
-import { Connection } from 'mongoose';
-
 import fs = require('fs');
+import { Connection } from 'mongoose';
 import YumlDiagram = require('yuml-diagram');
 
 /**

package/src/core/common/services/module.service.ts

@@ -1,3 +1,4 @@
+import _ = require('lodash');
 import { Document, Model, Types } from 'mongoose';
 
 import { ProcessType } from '../enums/process-type.enum';
@@ -9,8 +10,6 @@ import { CoreModel } from '../models/core-model.model';
 import { FieldSelection } from '../types/field-selection.type';
 import { ConfigService } from './config.service';
 
-import _ = require('lodash');
-
 /**
  * Module service class to be extended by concrete module services
  */

package/src/core/common/services/template.service.ts

@@ -1,12 +1,11 @@
 import { Injectable } from '@nestjs/common';
 import { TemplateFunction } from 'ejs';
+import ejs = require('ejs');
+import fs = require('fs');
 import { join } from 'path';
 
 import { ConfigService } from './config.service';
 
-import ejs = require('ejs');
-import fs = require('fs');
-
 /**
  * Template service
  */

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

@@ -1,7 +1,7 @@
-import { Field, ObjectType } from '@nestjs/graphql';
-import { ApiProperty } from '@nestjs/swagger';
+import { ObjectType } from '@nestjs/graphql';
 
 import { Restricted } from '../../common/decorators/restricted.decorator';
+import { UnifiedField } from '../../common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../common/enums/role.enum';
 import { CoreModel } from '../../common/models/core-model.model';
 import { CoreUserModel } from '../user/core-user.model';
@@ -19,35 +19,34 @@ export class CoreAuthModel extends CoreModel {
   /**
    * JSON Web Token(JWT)
    */
-  @ApiProperty({
+  @UnifiedField({
     description: 'JSON Web Token(JWT) used for auth',
     example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Field({ description: 'JSON Web Token(JWT)', nullable: true })
-  @Restricted(RoleEnum.S_EVERYONE)
   token?: string = undefined;
 
   /**
    * Refresh token
    */
-  @ApiProperty({
+  @UnifiedField({
     description: 'Refresh JSON Web Token(JWT) used for auth',
     example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
   })
-  @Field({ description: 'Refresh token', nullable: true })
-  @Restricted(RoleEnum.S_EVERYONE)
   refreshToken?: string = undefined;
 
   /**
    * Current user
    */
-  @ApiProperty({
+  @UnifiedField({
     description: 'User who signed in',
-    required: true,
+    isOptional: false,
+    roles: RoleEnum.S_EVERYONE,
     type: () => CoreUserModel,
   })
-  @Field({ description: 'Current user' })
-  @Restricted(RoleEnum.S_EVERYONE)
   user: CoreUserModel = undefined;
 
   // ===================================================================================================================

package/src/core/modules/auth/guards/auth.guard.ts

@@ -3,14 +3,13 @@ import { GqlExecutionContext } from '@nestjs/graphql';
 import { AuthModuleOptions, Type } from '@nestjs/passport';
 import { defaultOptions } from '@nestjs/passport/dist/options';
 import { memoize } from '@nestjs/passport/dist/utils/memoize.util';
+import passport = require('passport');
 
 import { AuthGuardStrategy } from '../auth-guard-strategy.enum';
 import { ExpiredRefreshTokenException } from '../exceptions/expired-refresh-token.exception';
 import { ExpiredTokenException } from '../exceptions/expired-token.exception';
 import { InvalidTokenException } from '../exceptions/invalid-token.exception';
 
-import passport = require('passport');
-
 /**
  * Missing strategy error
  */

package/src/core/modules/auth/inputs/core-auth-sign-in.input.ts

@@ -1,8 +1,8 @@
-import { Field, InputType } from '@nestjs/graphql';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import { InputType } from '@nestjs/graphql';
+import { IsEmail, IsNotEmpty, IsString } from 'class-validator';
 
 import { Restricted } from '../../../common/decorators/restricted.decorator';
+import { UnifiedField } from '../../../common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../../common/enums/role.enum';
 import { CoreInput } from '../../../common/inputs/core-input.input';
 
@@ -16,31 +16,35 @@ export class CoreAuthSignInInput extends CoreInput {
   // Properties
   // ===================================================================================================================
 
-  @ApiPropertyOptional({ description: 'Device ID (is created automatically if it is not set)' })
-  @Field({ description: 'Device ID (is created automatically if it is not set)', nullable: true })
-  @IsOptional()
-  @IsString()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Device ID (is created automatically if it is not set)',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsString()],
+  })
   deviceId?: string = undefined;
 
-  @ApiPropertyOptional({ description: 'Device description' })
-  @Field({ description: 'Device description', nullable: true })
-  @IsOptional()
-  @IsString()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Device description',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsString()],
+  })
   deviceDescription?: string = undefined;
 
-  @ApiProperty()
-  @Field({ description: 'Email', nullable: false })
-  @IsEmail()
-  @IsNotEmpty()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Email',
+    isOptional: false,
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsEmail(), IsString(), IsNotEmpty()],
+  })
   email: string = undefined;
 
-  @ApiProperty()
-  @Field({ description: 'Password', nullable: false })
-  @IsNotEmpty()
-  @IsString()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Password',
+    isOptional: false,
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsString(), IsNotEmpty()],
+  })
   password: string = undefined;
 }

package/src/core/modules/auth/services/core-auth.service.ts

@@ -1,5 +1,6 @@
 import { BadRequestException, Injectable, UnauthorizedException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
+import bcrypt = require('bcrypt');
 import { randomUUID } from 'crypto';
 import { sha256 } from 'js-sha256';
 
@@ -14,8 +15,6 @@ import { ICoreAuthUser } from '../interfaces/core-auth-user.interface';
 import { JwtPayload } from '../interfaces/jwt-payload.interface';
 import { CoreAuthUserService } from './core-auth-user.service';
 
-import bcrypt = require('bcrypt');
-
 /**
  * CoreAuthService to handle user authentication
  */

package/src/core/modules/health-check/core-health-check-result.model.ts

@@ -1,6 +1,7 @@
-import { Field, ObjectType } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
 
 import { Restricted } from '../../common/decorators/restricted.decorator';
+import { UnifiedField } from '../../common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../common/enums/role.enum';
 import { CoreModel } from '../../common/models/core-model.model';
 import { JSON } from '../../common/scalars/json.scalar';
@@ -18,37 +19,43 @@ export abstract class CoreHealthCheckResult extends CoreModel {
   /**
    * The overall status of the Health Check
    */
-  @Field({ description: 'The overall status of the Health Check', nullable: false })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'The overall status of the Health Check',
+    isOptional: false,
+    roles: RoleEnum.S_EVERYONE,
+  })
   status: 'error' | 'ok' | 'shutting_down' = undefined;
 
   /**
    * The info object contains information of each health indicator which is of status “up”
    */
-  @Field(() => JSON, {
+  @UnifiedField({
     description: 'The info object contains information of each health indicator which is of status “up”',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    type: () => JSON,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   info: JSON = undefined;
 
   /**
    * The error object contains information of each health indicator which is of status “down”
    */
-  @Field(() => JSON, {
+  @UnifiedField({
     description: 'The error object contains information of each health indicator which is of status “down”',
-    nullable: true,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    type: () => JSON,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   error: JSON = undefined;
 
   /**
    * The details object contains information of every health indicator
    */
-  @Field(() => JSON, {
+  @UnifiedField({
     description: 'The details object contains information of every health indicator',
-    nullable: false,
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    type: () => JSON,
   })
-  @Restricted(RoleEnum.S_EVERYONE)
   details: JSON = undefined;
 }

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

@@ -1,4 +1,6 @@
 import { BadRequestException, NotFoundException, UnprocessableEntityException } from '@nestjs/common';
+import bcrypt = require('bcrypt');
+import crypto = require('crypto');
 import { sha256 } from 'js-sha256';
 import { Document, Model } from 'mongoose';
 
@@ -12,9 +14,6 @@ import { CoreUserModel } from './core-user.model';
 import { CoreUserCreateInput } from './inputs/core-user-create.input';
 import { CoreUserInput } from './inputs/core-user.input';
 
-import bcrypt = require('bcrypt');
-import crypto = require('crypto');
-
 /**
  * User service
  */

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

@@ -1,7 +1,8 @@
-import { Field, InputType } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
 import { IsEmail } from 'class-validator';
 
 import { Restricted } from '../../../common/decorators/restricted.decorator';
+import { UnifiedField } from '../../../common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../../common/enums/role.enum';
 import { CoreUserInput } from './core-user.input';
 
@@ -15,8 +16,10 @@ import { CoreUserInput } from './core-user.input';
 @InputType({ description: 'User input to create a new user', isAbstract: true })
 @Restricted(RoleEnum.S_EVERYONE)
 export abstract class CoreUserCreateInput extends CoreUserInput {
-  @Field({ description: 'Email of the user', nullable: false })
-  @IsEmail()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Email of the user',
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsEmail()],
+  })
   override email: string = undefined;
 }

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

@@ -1,7 +1,8 @@
-import { Field, InputType } from '@nestjs/graphql';
-import { IsEmail, IsOptional } from 'class-validator';
+import { InputType } from '@nestjs/graphql';
+import { IsEmail } from 'class-validator';
 
 import { Restricted } from '../../../common/decorators/restricted.decorator';
+import { UnifiedField } from '../../../common/decorators/unified-field.decorator';
 import { ProcessType } from '../../../common/enums/process-type.enum';
 import { RoleEnum } from '../../../common/enums/role.enum';
 import { CoreInput } from '../../../common/inputs/core-input.input';
@@ -19,49 +20,62 @@ export abstract class CoreUserInput extends CoreInput {
   /**
    * Email of the user
    */
-  @Field({ description: 'Email of the user', nullable: true })
-  @IsEmail()
-  @IsOptional()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Email of the user',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+    validator: () => [IsEmail()],
+  })
   email?: string = undefined;
 
   /**
    * First name of the user
    */
-  @Field({ description: 'First name of the user', nullable: true })
-  @IsOptional()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Last name of the user',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   firstName?: string = undefined;
 
   /**
    * Last name of the user
    */
-  @Field({ description: 'Last name of the user', nullable: true })
-  @IsOptional()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Last name of the user',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   lastName?: string = undefined;
 
   /**
    * Roles of the user
    */
-  @Field(() => [String], { description: 'Roles of the user', nullable: true })
-  @IsOptional()
   @Restricted({ processType: ProcessType.INPUT, roles: RoleEnum.ADMIN })
+  @UnifiedField({
+    array: true,
+    isOptional: true,
+    type: String,
+  })
   roles?: string[] = undefined;
 
   /**
    * Username / alias of the user
    */
-  @Field({ description: 'Username / alias of the user', nullable: true })
-  @IsOptional()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Username / alias of the user',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   username?: string = undefined;
 
   /**
    * Password of the user
    */
-  @Field({ description: 'Password of the user', nullable: true })
-  @IsOptional()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Password of the user',
+    isOptional: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   password?: string = undefined;
 }