@lenne.tech/nest-server 11.1.14 → 11.3.0

package/src/core/modules/file/core-file-info.model.ts

@@ -1,8 +1,8 @@
-import { Field, ObjectType } from '@nestjs/graphql';
-import { Prop } from '@nestjs/mongoose';
+import { ObjectType } from '@nestjs/graphql';
 import { Types } from 'mongoose';
 
 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';
 
@@ -25,37 +25,55 @@ export class CoreFileInfo extends CoreModel {
   // Properties
   // ===========================================================================
 
-  @Field(() => String, { description: 'ID of the file' })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'ID of the file',
+    roles: RoleEnum.S_EVERYONE,
+    type: () => String,
+  })
   id: string = undefined;
 
-  @Field(() => Number, {
+  @UnifiedField({
     description:
-      'The size of each chunk in bytes. GridFS divides the document into chunks of size chunkSize, '
-      + 'except for the last, which is only as large as needed. The default size is 255 kilobytes (kB)',
-    nullable: true,
+      'The size of each chunk in bytes. GridFS divides the document into chunks of size chunkSize, ' +
+      'except for the last, which is only as large as needed. The default size is 255 kilobytes (kB)',
+    isOptional: true,
+    mongoose: { required: false, type: Number },
+    roles: RoleEnum.S_EVERYONE,
+    type: () => Number,
   })
-  @Prop({ required: false, type: Number })
-  @Restricted(RoleEnum.S_EVERYONE)
   chunkSize: number = undefined;
 
-  @Field(() => String, { description: 'Content type', nullable: true })
-  @Prop({ required: false, type: String })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Content type',
+    isOptional: true,
+    mongoose: { required: false, type: String },
+    roles: RoleEnum.S_EVERYONE,
+  })
   contentType?: string = undefined;
 
-  @Field(() => String, { description: 'Name of the file', nullable: true })
-  @Prop({ required: false, type: String })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Name of the file',
+    isOptional: true,
+    mongoose: { required: false, type: String },
+    roles: RoleEnum.S_EVERYONE,
+  })
   filename?: string = undefined;
 
-  @Field(() => Number, { description: 'The size of the document in bytes', nullable: true })
-  @Prop({ required: false, type: Number })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'The size of the document in bytes',
+    isOptional: true,
+    mongoose: { required: false, type: Number },
+    roles: RoleEnum.S_EVERYONE,
+    type: () => Number,
+  })
   length: number = undefined;
 
-  @Field(() => Date, { description: 'The date the file was first stored', nullable: true })
-  @Prop({ required: false, type: Date })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'The date the file was first stored',
+    isOptional: true,
+    mongoose: { required: false, type: Date },
+    roles: RoleEnum.S_EVERYONE,
+    type: () => Date,
+  })
   uploadDate: Date = undefined;
 }

package/src/core/modules/file/core-file.controller.ts

@@ -1,4 +1,5 @@
 import { BadRequestException, Controller, Get, NotFoundException, Param, Res } from '@nestjs/common';
+import { Response } from 'express';
 
 import { Roles } from '../../common/decorators/roles.decorator';
 import { RoleEnum } from '../../common/enums/role.enum';
@@ -20,7 +21,7 @@ export abstract class CoreFileController {
    */
   @Get(':filename')
   @Roles(RoleEnum.S_EVERYONE)
-  async getFile(@Param('filename') filename: string, @Res() res) {
+  async getFile(@Param('filename') filename: string, @Res() res: Response) {
     if (!filename) {
       throw new BadRequestException('Missing filename for download');
     }
@@ -30,7 +31,7 @@ export abstract class CoreFileController {
       throw new NotFoundException('File not found');
     }
     const filestream = await this.fileService.getFileStream(file.id);
-    res.header('Content-Type', file.contentType);
+    res.header('Content-Type', file.contentType || 'application/octet-stream');
     res.header('Content-Disposition', `attachment; filename=${file.filename}`);
     return filestream.pipe(res);
   }

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

@@ -1,11 +1,10 @@
-import { createBucket, MongoGridFSOptions, MongooseGridFS } from '@lenne.tech/mongoose-gridfs';
 import { NotFoundException } from '@nestjs/common';
-import { GridFSBucket, GridFSBucketReadStream, GridFSBucketReadStreamOptions } from 'mongodb';
-import mongoose, { Connection, Types } from 'mongoose';
+import mongoose, { Connection, mongo, Types } from 'mongoose';
 
 import { FilterArgs } from '../../common/args/filter.args';
 import { getObjectIds, getStringIds } from '../../common/helpers/db.helper';
 import { convertFilterArgsToQuery } from '../../common/helpers/filter.helper';
+import { GridFSHelper } from '../../common/helpers/gridfs.helper';
 import { check } from '../../common/helpers/input.helper';
 import { prepareOutput } from '../../common/helpers/service.helper';
 import { MaybePromise } from '../../common/types/maybe-promise.type';
@@ -22,7 +21,8 @@ export type FileInputCheckType = 'file' | 'filename' | 'files' | 'filterArgs' |
  * Abstract core file service
  */
 export abstract class CoreFileService {
-  files: GridFSBucket & MongooseGridFS;
+  // Use the native MongoDB driver's types (accessed via Mongoose's exports) to avoid BSON version conflicts
+  files: mongo.GridFSBucket;
 
   /**
    * Include MongoDB connection and create File bucket
@@ -31,7 +31,8 @@ export abstract class CoreFileService {
     protected readonly connection: Connection,
     bucketName = 'fs',
   ) {
-    this.files = createBucket({ bucketName, connection });
+    // Use the native MongoDB driver's GridFSBucket via Mongoose's mongo export to avoid BSON version conflicts
+    this.files = new mongo.GridFSBucket(connection.db, { bucketName });
   }
 
   /**
@@ -41,15 +42,13 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(file, { ...serviceOptions, checkInputType: 'file' }))) {
       return null;
     }
-    return await new Promise(async (resolve, reject) => {
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      const { createReadStream, encoding, filename, mimetype } = await file;
-      const readStream = createReadStream();
-      const options: MongoGridFSOptions = { contentType: mimetype, filename };
-      this.files.writeFile(options, readStream, (error, fileInfo) => {
-        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
-      });
+    const { createReadStream, filename, mimetype } = await file;
+    const readStream = createReadStream();
+    const fileInfo = await GridFSHelper.writeFileFromStream(this.files, readStream, {
+      contentType: mimetype,
+      filename,
     });
+    return this.prepareOutput(fileInfo as unknown as CoreFileInfo, serviceOptions);
   }
 
   /**
@@ -71,7 +70,11 @@ export abstract class CoreFileService {
    */
   async duplicateByName(name: string, newName: string): Promise<any> {
     return new Promise(async (resolve) => {
-      resolve(this.files.openDownloadStreamByName(name).pipe(this.files.openUploadStream(newName)));
+      resolve(
+        GridFSHelper.openDownloadStreamByName(this.files, name).pipe(
+          GridFSHelper.openUploadStream(this.files, newName),
+        ),
+      );
     });
   }
 
@@ -82,10 +85,10 @@ export abstract class CoreFileService {
     const objectId = getObjectIds(id);
     const file = await this.getFileInfo(objectId);
     return new Promise((resolve, reject) => {
-      const downloadStream = this.files.openDownloadStream(objectId);
+      const downloadStream = GridFSHelper.openDownloadStream(this.files, objectId);
 
       const newFileId = new mongoose.Types.ObjectId();
-      const uploadStream = this.files.openUploadStreamWithId(newFileId, file.filename, {
+      const uploadStream = GridFSHelper.openUploadStreamWithId(this.files, newFileId, file.filename, {
         contentType: file.contentType,
       });
 
@@ -112,16 +115,9 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(filterArgs, { ...serviceOptions, checkInputType: 'filterArgs' }))) {
       return null;
     }
-    return await new Promise((resolve, reject) => {
-      const filterQuery = convertFilterArgsToQuery(filterArgs);
-      const cursor = this.files.find(filterQuery[0], filterQuery[1]);
-      if (!cursor) {
-        throw new NotFoundException('File collection not found');
-      }
-      cursor.toArray((error, docs) => {
-        error ? reject(error) : resolve(this.prepareOutput(docs, serviceOptions));
-      });
-    });
+    const filterQuery = convertFilterArgsToQuery(filterArgs);
+    const docs = await GridFSHelper.findFiles(this.files, filterQuery[0], filterQuery[1]);
+    return this.prepareOutput(docs as unknown as CoreFileInfo[], serviceOptions);
   }
 
   /**
@@ -131,11 +127,8 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(id, { ...serviceOptions, checkInputType: 'id' }))) {
       return null;
     }
-    return await new Promise((resolve, reject) => {
-      this.files.findById(getObjectIds(id), (error, fileInfo) => {
-        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
-      });
-    });
+    const fileInfo = await GridFSHelper.findFileById(this.files, getObjectIds(id));
+    return this.prepareOutput(fileInfo as unknown as CoreFileInfo, serviceOptions);
   }
 
   /**
@@ -145,11 +138,8 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(filename, { ...serviceOptions, checkInputType: 'filename' }))) {
       return null;
     }
-    return await new Promise((resolve, reject) => {
-      this.files.findOne({ filename }, (error, fileInfo) => {
-        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
-      });
-    });
+    const fileInfo = await GridFSHelper.findFileByName(this.files, filename);
+    return this.prepareOutput(fileInfo as unknown as CoreFileInfo, serviceOptions);
   }
 
   /**
@@ -159,7 +149,7 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(id, { ...serviceOptions, checkInputType: 'id' }))) {
       return null;
     }
-    return this.files.openDownloadStream(getObjectIds(id)) as GridFSBucketReadStream;
+    return GridFSHelper.openDownloadStream(this.files, getObjectIds(id)) as mongo.GridFSBucketReadStream;
   }
 
   /**
@@ -168,11 +158,11 @@ export abstract class CoreFileService {
   async getFileStreamByName(
     filename: string,
     serviceOptions?: FileServiceOptions,
-  ): Promise<GridFSBucketReadStreamOptions> {
+  ): Promise<mongo.GridFSBucketReadStream> {
     if (!(await this.checkRights(filename, { ...serviceOptions, checkInputType: 'filename' }))) {
       return null;
     }
-    return this.files.readFile({ filename });
+    return GridFSHelper.openDownloadStreamByName(this.files, filename);
   }
 
   /**
@@ -182,39 +172,30 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(id, { ...serviceOptions, checkInputType: 'id' }))) {
       return null;
     }
-    return await new Promise((resolve, reject) => {
-      this.files.readFile({ _id: getObjectIds(id) }, (error, buffer) => {
-        error ? reject(error) : resolve(buffer);
-      });
-    });
+    return await GridFSHelper.readFileToBuffer(this.files, { _id: getObjectIds(id) });
   }
 
   /**
-   * Get file buffer (for small files) via file ID
+   * Get file buffer (for small files) via filename
    */
   async getBufferByName(filename: string, serviceOptions?: FileServiceOptions): Promise<Buffer> {
     if (!(await this.checkRights(filename, { ...serviceOptions, checkInputType: 'filename' }))) {
       return null;
     }
-    return await new Promise((resolve, reject) => {
-      this.files.readFile({ filename }, (error, buffer) => {
-        error ? reject(error) : resolve(buffer);
-      });
-    });
+    return await GridFSHelper.readFileToBuffer(this.files, { filename });
   }
 
   /**
-   * Delete file reference of avatar
+   * Delete file
    */
   async deleteFile(id: string | Types.ObjectId, serviceOptions?: FileServiceOptions): Promise<CoreFileInfo> {
     if (!(await this.checkRights(id, { ...serviceOptions, checkInputType: 'id' }))) {
       return null;
     }
-    return await new Promise((resolve, reject) => {
-      return this.files.unlink(getObjectIds(id), (error, fileInfo) => {
-        error ? reject(error) : resolve(this.prepareOutput(fileInfo, serviceOptions));
-      });
-    });
+    const objectId = getObjectIds(id);
+    const fileInfo = await this.getFileInfo(objectId, serviceOptions);
+    await GridFSHelper.deleteFile(this.files, objectId);
+    return fileInfo;
   }
 
   /**
@@ -247,15 +228,23 @@ export abstract class CoreFileService {
   }
 
   /**
-   * Prepare output before return
+   * Prepare output before return - single file
+   * Accepts both GridFSFileInfo (from GridFS operations) and CoreFileInfo
+   * They are structurally compatible (duck typing), so we use type assertion
    */
-  protected async prepareOutput(fileInfo: CoreFileInfo | CoreFileInfo[], options?: FileServiceOptions) {
+  protected async prepareOutput(fileInfo: CoreFileInfo, options?: FileServiceOptions): Promise<CoreFileInfo>;
+  protected async prepareOutput(fileInfo: null, options?: FileServiceOptions): Promise<null>;
+  protected async prepareOutput(fileInfo: CoreFileInfo[], options?: FileServiceOptions): Promise<CoreFileInfo[]>;
+  protected async prepareOutput(
+    fileInfo: CoreFileInfo | CoreFileInfo[] | null,
+    options?: FileServiceOptions,
+  ): Promise<CoreFileInfo | CoreFileInfo[] | null> {
     if (!fileInfo) {
       return fileInfo;
     }
     this.setId(fileInfo);
-    fileInfo = await prepareOutput(fileInfo, { targetModel: CoreFileInfo });
-    return check(fileInfo, options?.currentUser, { roles: options?.roles });
+    const prepared = await prepareOutput(fileInfo, { targetModel: CoreFileInfo });
+    return check(prepared, options?.currentUser, { roles: options?.roles });
   }
 
   /**

package/src/core/modules/file/interfaces/file-upload.interface.ts

@@ -23,8 +23,9 @@ export interface FileUpload {
 
   /**
    * Stream transfer encoding of the file
+   * @deprecated This property is deprecated and may be removed in future versions
    */
-  encoding: string;
+  encoding?: string;
 
   /**
    * Name of the file

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

@@ -1,10 +1,10 @@
-import { Field, ObjectType } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
 import { Schema as MongooseSchema, Prop, raw } from '@nestjs/mongoose';
 import { ApiExtraModels, ApiProperty } from '@nestjs/swagger';
-import { IsOptional } from 'class-validator';
 import { Document } from 'mongoose';
 
 import { Restricted } from '../../common/decorators/restricted.decorator';
+import { UnifiedField } from '../../common/decorators/unified-field.decorator';
 import { RoleEnum } from '../../common/enums/role.enum';
 import { CorePersistenceModel } from '../../common/models/core-persistence.model';
 import { CoreTokenData } from '../auth/interfaces/core-token-data.interface';
@@ -26,67 +26,78 @@ export abstract class CoreUserModel extends CorePersistenceModel {
   /**
    * E-Mail address of the user
    */
-  @ApiProperty()
-  @Field({ description: 'Email of the user', nullable: true })
-  @Prop({ index: true, lowercase: true, trim: true })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Email of the user',
+    isOptional: true,
+    mongoose: { index: true, lowercase: true, trim: true },
+    roles: RoleEnum.S_EVERYONE,
+  })
   email: string = undefined;
 
   /**
    * First name of the user
    */
-  @ApiProperty()
-  @Field({ description: 'First name of the user', nullable: true })
-  @IsOptional()
-  @Prop()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'First name of the user',
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   firstName: string = undefined;
 
   /**
    * Last name of the user
    */
-  @ApiProperty()
-  @Field({ description: 'Last name of the user', nullable: true })
-  @IsOptional()
-  @Prop()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Last name of the user',
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   lastName: string = undefined;
 
   /**
    * Password of the user
    */
-  @ApiProperty()
-  @Prop()
-  @Restricted(RoleEnum.S_NO_ONE)
+  @UnifiedField({
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_NO_ONE,
+  })
   password: string = undefined;
 
   /**
    * Roles of the user
    */
-  @ApiProperty()
-  @Field(() => [String], { description: 'Roles of the user', nullable: true })
-  @IsOptional()
-  @Prop([String])
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Roles of the user',
+    isArray: true,
+    isOptional: true,
+    mongoose: [String],
+    roles: RoleEnum.S_EVERYONE,
+    type: () => String,
+  })
   roles: string[] = undefined;
 
   /**
    * Username of the user
    */
-  @ApiProperty()
-  @Field({ description: 'Username of the user', nullable: true })
-  @IsOptional()
-  @Prop()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Username of the user',
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   username: string = undefined;
 
   /**
    * Password reset token of the user
    */
-  @ApiProperty()
-  @IsOptional()
-  @Prop()
-  @Restricted(RoleEnum.S_NO_ONE)
+  @UnifiedField({
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_NO_ONE,
+  })
   passwordResetToken: string = undefined;
 
   /**
@@ -96,30 +107,41 @@ export abstract class CoreUserModel extends CorePersistenceModel {
    */
   @ApiProperty({ isArray: true })
   @ApiProperty({
-      additionalProperties: {
+    additionalProperties: {
       properties: {
-        deviceDescription: { description: 'Description of the device from which the token was generated', nullable: true, type: 'string' },
-        deviceId: { description: 'ID of the device from which the token was generated', nullable: true, type: 'string' },
-        tokenId: { description: 'Token ID to make sure that there is only one RefreshToken for each device', nullable: false, type: 'string' },
+        deviceDescription: {
+          description: 'Description of the device from which the token was generated',
+          nullable: true,
+          type: 'string',
+        },
+        deviceId: {
+          description: 'ID of the device from which the token was generated',
+          nullable: true,
+          type: 'string',
+        },
+        tokenId: {
+          description: 'Token ID to make sure that there is only one RefreshToken for each device',
+          nullable: false,
+          type: 'string',
+        },
       },
       type: 'object',
     },
     description: 'Refresh tokens for devices (key: Token, value: TokenData)',
     example: {
-        '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb': {
-          deviceDescription: null,
-          deviceId: '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb',
-          tokenId: '50937407-4282-480e-8679-14ecc113f9c7',
-        },
-        'e9e60a3e-2004-479f-8e79-13a0d1981d76': {
-          deviceDescription: null,
-          deviceId: 'e9e60a3e-2004-479f-8e79-13a0d1981d76',
-          tokenId: '0604aa59-4fc8-4848-9fe7-c12d9cdf6ec0',
-        },
+      '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb': {
+        deviceDescription: null,
+        deviceId: '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb',
+        tokenId: '50937407-4282-480e-8679-14ecc113f9c7',
+      },
+      'e9e60a3e-2004-479f-8e79-13a0d1981d76': {
+        deviceDescription: null,
+        deviceId: 'e9e60a3e-2004-479f-8e79-13a0d1981d76',
+        tokenId: '0604aa59-4fc8-4848-9fe7-c12d9cdf6ec0',
       },
+    },
     type: 'object',
   })
-  @IsOptional()
   @Prop(raw({}))
   @Restricted(RoleEnum.S_NO_ONE)
   refreshTokens: Record<string, CoreTokenData> = undefined;
@@ -130,30 +152,44 @@ export abstract class CoreUserModel extends CorePersistenceModel {
    */
   @ApiProperty()
   @ApiProperty({
-      additionalProperties: {
+    additionalProperties: {
       properties: {
-        createdAt: { description: 'Token Created At', example: 1740037703939, format: 'int64', nullable: true, type: 'number' },
-        deviceId: { description: 'ID of the device from which the token was generated', nullable: true, type: 'string' },
-        tokenId: { description: 'Token ID to make sure that there is only one RefreshToken for each device', nullable: false, type: 'string' },
+        createdAt: {
+          description: 'Token Created At',
+          example: 1740037703939,
+          format: 'int64',
+          nullable: true,
+          type: 'number',
+        },
+        deviceId: {
+          description: 'ID of the device from which the token was generated',
+          nullable: true,
+          type: 'string',
+        },
+        tokenId: {
+          description: 'Token ID to make sure that there is only one RefreshToken for each device',
+          nullable: false,
+          type: 'string',
+        },
       },
       type: 'object',
     },
     description: 'Temporary token for parallel requests during the token refresh process',
-    example: { // 👈 Add explicit example keys
-        '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb': {
-          createdAt: 1740037703939,
-          deviceId: '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb',
-          tokenId: '50937407-4282-480e-8679-14ecc113f9c7',
-        },
-        'f83ae5f6-90bf-4b4e-b318-651e0eaa67ae': {
-          createdAt: 1740037703940,
-          deviceId: 'f83ae5f6-90bf-4b4e-b318-651e0eaa67ae',
-          tokenId: '4f0dc3c5-e74e-41f4-9bd9-642869462c1e',
-        },
+    example: {
+      // 👈 Add explicit example keys
+      '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb': {
+        createdAt: 1740037703939,
+        deviceId: '49b5c7d6-94ae-4efe-b377-9b50d1a9c2cb',
+        tokenId: '50937407-4282-480e-8679-14ecc113f9c7',
       },
+      'f83ae5f6-90bf-4b4e-b318-651e0eaa67ae': {
+        createdAt: 1740037703940,
+        deviceId: 'f83ae5f6-90bf-4b4e-b318-651e0eaa67ae',
+        tokenId: '4f0dc3c5-e74e-41f4-9bd9-642869462c1e',
+      },
+    },
     type: 'object',
   })
-  @IsOptional()
   @Prop(raw({}))
   @Restricted(RoleEnum.S_NO_ONE)
   tempTokens: Record<string, { createdAt: number; deviceId: string; tokenId: string }> = undefined;
@@ -161,28 +197,34 @@ export abstract class CoreUserModel extends CorePersistenceModel {
   /**
    * Verification token of the user
    */
-  @ApiProperty()
-  @IsOptional()
-  @Prop()
-  @Restricted(RoleEnum.S_NO_ONE)
+  @UnifiedField({
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_NO_ONE,
+  })
   verificationToken: string = undefined;
 
   /**
    * Verification of the user
    */
-  @ApiProperty()
-  @Field(() => Boolean, { description: 'Verification state of the user', nullable: true })
-  @Prop({ type: Boolean })
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Verification state of the user',
+    isOptional: true,
+    mongoose: { type: Boolean },
+    roles: RoleEnum.S_EVERYONE,
+    type: () => Boolean,
+  })
   verified: boolean = undefined;
 
   /**
    * Verification date
    */
-  @ApiProperty()
-  @Field({ description: 'Verified date', nullable: true })
-  @Prop()
-  @Restricted(RoleEnum.S_EVERYONE)
+  @UnifiedField({
+    description: 'Verified date',
+    isOptional: true,
+    mongoose: true,
+    roles: RoleEnum.S_EVERYONE,
+  })
   verifiedAt: Date = undefined;
 
   // ===================================================================================================================
@@ -199,7 +241,7 @@ export abstract class CoreUserModel extends CorePersistenceModel {
     if (!this.roles || this.roles.length < 1) {
       return false;
     }
-    return !roles || roles.length < 1 ? true : this.roles.some(role => roles.includes(role));
+    return !roles || roles.length < 1 ? true : this.roles.some((role) => roles.includes(role));
   }
 
   /**
@@ -212,7 +254,7 @@ export abstract class CoreUserModel extends CorePersistenceModel {
     if (!this.roles || this.roles.length < 1) {
       return false;
     }
-    return !roles ? true : roles.every(role => this.roles.includes(role));
+    return !roles ? true : roles.every((role) => this.roles.includes(role));
   }
 
   /**

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

@@ -115,9 +115,9 @@ export abstract class CoreUserService<
     return this.process(
       async () => {
         // Update and return user
-        return await this.mainDbModel
-          .updateOne({ _id: dbObject.id }, { verified: true, verifiedAt: new Date() }, { returnDocument: 'after' })
-          .exec();
+        await this.mainDbModel.updateOne({ _id: dbObject.id }, { verified: true, verifiedAt: new Date() }).exec();
+        // Return the updated user
+        return await this.mainDbModel.findById(dbObject.id).exec();
       },
       { dbObject, serviceOptions },
     );