@lenne.tech/nest-server 11.1.14 → 11.2.0

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.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 },
     );

package/src/index.ts

@@ -34,6 +34,7 @@ export * from './core/common/helpers/decorator.helper';
 export * from './core/common/helpers/file.helper';
 export * from './core/common/helpers/filter.helper';
 export * from './core/common/helpers/graphql.helper';
+export * from './core/common/helpers/gridfs.helper';
 export * from './core/common/helpers/input.helper';
 export * from './core/common/helpers/model.helper';
 export * from './core/common/helpers/scim.helper';

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

@@ -11,13 +11,17 @@ import {
   UseInterceptors,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
+import { Response } from 'express';
+import { Readable } from 'stream';
 
 import { Roles } from '../../../core/common/decorators/roles.decorator';
 import { RoleEnum } from '../../../core/common/enums/role.enum';
+import { CoreFileInfo } from '../../../core/modules/file/core-file-info.model';
+import { FileUpload } from '../../../core/modules/file/interfaces/file-upload.interface';
 import { FileService } from './file.service';
 
 /**
- * File controller for
+ * File controller
  */
 @Controller('files')
 @Roles(RoleEnum.ADMIN)
@@ -28,13 +32,26 @@ export class FileController {
   constructor(private readonly fileService: FileService) {}
 
   /**
-   * Upload file
+   * Upload file via HTTP
    */
   @Post('upload')
   @Roles(RoleEnum.ADMIN)
   @UseInterceptors(FileInterceptor('file'))
-  uploadFile(@UploadedFile() file: Express.Multer.File): any {
-    return file;
+  async uploadFile(@UploadedFile() file: Express.Multer.File): Promise<any> {
+    if (!file) {
+      throw new BadRequestException('No file provided');
+    }
+
+    // Convert Multer file to FileUpload interface
+    const fileUpload: FileUpload = {
+      capacitor: null, // Not used when creating from buffer
+      createReadStream: () => Readable.from(file.buffer),
+      filename: file.originalname,
+      mimetype: file.mimetype,
+    };
+
+    // Save to GridFS using FileService
+    return await this.fileService.createFile(fileUpload);
   }
 
   /**
@@ -42,23 +59,24 @@ export class FileController {
    */
   @Get(':id')
   @Roles(RoleEnum.ADMIN)
-  async getFile(@Param('id') id: string, @Res() res) {
+  async getFile(@Param('id') id: string, @Res() res: Response) {
     if (!id) {
       throw new BadRequestException('Missing ID');
     }
 
-    let file;
+    let file: CoreFileInfo | null;
     try {
       file = await this.fileService.getFileInfo(id);
     } catch (e) {
       console.error(e);
+      file = null;
     }
 
     if (!file) {
       throw new NotFoundException('File not found');
     }
     const filestream = await this.fileService.getFileStream(id);
-    res.header('Content-Type', file.contentType);
+    res.header('Content-Type', file.contentType || 'application/octet-stream');
     res.header('Content-Disposition', `attachment; filename=${file.filename}`);
     res.header('Cache-Control', 'max-age=31536000');
     return filestream.pipe(res);

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

@@ -64,8 +64,7 @@ export class FileResolver {
     // Save files in filesystem
     const promises: Promise<any>[] = [];
     for (const file of files) {
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      const { createReadStream, encoding, filename, mimetype } = await file;
+      const { createReadStream, filename } = await file;
       await fs.promises.mkdir('./uploads', { recursive: true });
       promises.push(
         new Promise((resolve, reject) =>

package/src/server/modules/file/multer-config.service.ts

@@ -1,31 +1,16 @@
-import { GridFsStorage } from '@lenne.tech/multer-gridfs-storage';
 import { Injectable } from '@nestjs/common';
 import { MulterModuleOptions, MulterOptionsFactory } from '@nestjs/platform-express';
+import { memoryStorage } from 'multer';
 
-import envConfig from '../../../config.env';
-
+/**
+ * Multer configuration service using MemoryStorage
+ * Files are stored in memory as Buffer objects and then manually saved to GridFS
+ */
 @Injectable()
 export class GridFsMulterConfigService implements MulterOptionsFactory {
-  gridFsStorage: any;
-
-  constructor() {
-    this.gridFsStorage = new GridFsStorage({
-      file: (req, file) => {
-        return new Promise((resolve) => {
-          const filename = file.originalname.trim();
-          const fileInfo = {
-            filename,
-          };
-          resolve(fileInfo);
-        });
-      },
-      url: envConfig.mongoose.uri,
-    });
-  }
-
   createMulterOptions(): MulterModuleOptions {
     return {
-      storage: this.gridFsStorage,
+      storage: memoryStorage(),
     };
   }
 }

package/src/types/graphql-upload.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for graphql-upload
+ * graphql-upload uses deep imports, so we declare types for the specific modules
+ */
+
+declare module 'graphql-upload/graphqlUploadExpress.js' {
+  import { RequestHandler } from 'express';
+
+  interface GraphQLUploadOptions {
+    maxFiles?: number;
+    maxFileSize?: number;
+  }
+
+  function graphqlUploadExpress(options?: GraphQLUploadOptions): RequestHandler;
+
+  export = graphqlUploadExpress;
+}
+
+declare module 'graphql-upload/GraphQLUpload.js' {
+  import { GraphQLScalarType } from 'graphql';
+
+  const GraphQLUpload: GraphQLScalarType;
+
+  export = GraphQLUpload;
+}