feat: implement minio:// prefix format (v2.0.0 breaking change)

Author: Mishhub

src/interceptors/file-url-transform.interceptor.ts

@@ -4,7 +4,6 @@ import { map } from 'rxjs/operators';
 import { MinioService } from '../minio.service';
 import { Socket } from 'net';
 import { IncomingMessage, ServerResponse } from 'http';
-import { MINIO_FILE_FIELD_METADATA } from '../constants';
 
 @Injectable()
 export class FileUrlTransformInterceptor implements NestInterceptor {
@@ -31,6 +30,7 @@ export class FileUrlTransformInterceptor implements NestInterceptor {
 
   /**
    * Transforms URLs in the given data to presigned URLs using the Minio service.
+   * Only processes strings that start with minio:// prefix.
    * @param data - The data to transform.
    * @returns The transformed data with URLs replaced by presigned URLs.
    */
@@ -63,24 +63,14 @@ export class FileUrlTransformInterceptor implements NestInterceptor {
       return obj;
     }
 
-    // Get the schema if it's a Mongoose document
-    const schema = data.schema || (data.constructor && data.constructor.schema);
-
     // Process each property recursively
     for (const [key, value] of Object.entries(obj)) {
-      // Check if this field is decorated with FileSchemaField or FileColumn
-      const isFileField =
-        schema?.paths?.[key]?.options?.isFileField ||
-        this.hasFileFieldMetadata(data, key) ||
-        this.hasFileFieldMetadata(obj, key);
-
-      const inferredPath = !isFileField ? this.extractMinioPath(value) : null;
-
-      if ((isFileField || inferredPath) && typeof value === 'string') {
-        const split = inferredPath ?? this.splitBucketAndObject(value);
-        if (split) {
+      // Only process strings that start with minio:// prefix
+      if (typeof value === 'string' && value.startsWith('minio://')) {
+        const minioPath = this.minioService.parseMinioUrl(value);
+        if (minioPath) {
           try {
-            obj[key] = await this.minioService.getPresignedUrl(split.bucketName, split.objectName);
+            obj[key] = await this.minioService.getPresignedUrl(minioPath.bucketName, minioPath.objectName);
           } catch (error) {
             this.logger.error(`Error generating presigned URL for ${key}:`, error);
           }
@@ -107,42 +97,4 @@ export class FileUrlTransformInterceptor implements NestInterceptor {
     return obj;
   }
 
-  private hasFileFieldMetadata(target: unknown, propertyKey: string): boolean {
-    if (!target) return false;
-
-    const directMetadata = Reflect.getMetadata(MINIO_FILE_FIELD_METADATA, target, propertyKey);
-    if (directMetadata) {
-      return true;
-    }
-
-    const prototype = typeof target === 'object' ? Object.getPrototypeOf(target) : undefined;
-    if (!prototype) {
-      return false;
-    }
-
-    return Boolean(Reflect.getMetadata(MINIO_FILE_FIELD_METADATA, prototype, propertyKey));
-  }
-
-  private extractMinioPath(value: unknown): { bucketName: string; objectName: string } | null {
-    if (typeof value !== 'string') {
-      return null;
-    }
-
-    const split = this.splitBucketAndObject(value);
-    return split;
-  }
-
-  private splitBucketAndObject(value: string): { bucketName: string; objectName: string } | null {
-    if (!value.includes('/')) {
-      return null;
-    }
-    const [bucketName, ...pathParts] = value.split('/');
-    if (!bucketName || pathParts.length === 0) {
-      return null;
-    }
-    return {
-      bucketName,
-      objectName: pathParts.join('/'),
-    };
-  }
 }

src/interceptors/file.interceptor.ts

@@ -98,16 +98,16 @@ export class MinioFileInterceptor implements NestInterceptor {
   private async transformUrls(data: any): Promise<any> {
     if (!data) return data;
 
-    // // If it's a plain object (not a mongoose document), process it directly
+    // If it's a plain object (not a mongoose document), process it directly
     const obj = data.toJSON ? await data.toJSON() : data;
 
-    // Transform all fields that look like Minio paths (bucket-name/path)
+    // Transform all fields that start with minio:// prefix
     for (const [key, value] of Object.entries(obj)) {
-      if (typeof value === 'string' && value.includes('/')) {
-        const [bucketName, ...pathParts] = value.split('/');
-        if (pathParts.length > 0) {
+      if (typeof value === 'string' && value.startsWith('minio://')) {
+        const minioPath = this.minioService.parseMinioUrl(value);
+        if (minioPath) {
           try {
-            obj[key] = await this.minioService.getPresignedUrl(bucketName, pathParts.join('/'));
+            obj[key] = await this.minioService.getPresignedUrl(minioPath.bucketName, minioPath.objectName);
           } catch (error) {
             this.logger.error(`Error generating presigned URL for ${key}:`, error);
           }

src/minio.service.ts

@@ -241,7 +241,8 @@ export class MinioService implements OnModuleInit {
       'Content-Type': file.mimetype,
     });
 
-    return `${bucketName}/${fileName}`;
+    // Return minio:// format for explicit identification
+    return `minio://${bucketName}/${fileName}`;
   }
 
   async getPresignedUrl(bucketName: string, objectName: string): Promise<string> {
@@ -261,11 +262,61 @@ export class MinioService implements OnModuleInit {
     );
   }
 
-  async deleteFile(bucketName: string, objectName: string): Promise<void> {
+  /**
+   * Deletes a file from MinIO
+   * @param bucketName - Bucket name or minio:// URL
+   * @param objectName - Object name (optional if first param is minio:// URL)
+   * @returns Promise that resolves when file is deleted
+   */
+  async deleteFile(bucketName: string, objectName?: string): Promise<void> {
+    // If bucketName is a minio:// URL, parse it
+    if (bucketName.startsWith('minio://')) {
+      const parsed = this.parseMinioUrl(bucketName);
+      if (!parsed) {
+        throw new Error(`Invalid minio:// URL: ${bucketName}`);
+      }
+      await this.minioClient.removeObject(parsed.bucketName, parsed.objectName);
+      return;
+    }
+
+    // Otherwise, use bucketName and objectName as separate parameters
+    if (!objectName) {
+      throw new Error('objectName is required when bucketName is not a minio:// URL');
+    }
     await this.minioClient.removeObject(bucketName, objectName);
   }
 
   getMinioClient(): Minio.Client {
     return this.minioClient;
   }
+
+  /**
+   * Parses a minio:// URL to extract bucket name and object name
+   * @param minioUrl - URL in format minio://bucket-name/object-path
+   * @returns Object with bucketName and objectName, or null if invalid
+   */
+  parseMinioUrl(minioUrl: string): { bucketName: string; objectName: string } | null {
+    if (!minioUrl || typeof minioUrl !== 'string') {
+      return null;
+    }
+
+    if (!minioUrl.startsWith('minio://')) {
+      return null;
+    }
+
+    const path = minioUrl.substring(8); // Remove 'minio://' prefix
+    if (!path.includes('/')) {
+      return null;
+    }
+
+    const [bucketName, ...pathParts] = path.split('/');
+    if (!bucketName || pathParts.length === 0) {
+      return null;
+    }
+
+    return {
+      bucketName,
+      objectName: pathParts.join('/'),
+    };
+  }
 }