@hed-hog/core 0.0.355 → 0.0.358

package/src/file/file.service.ts

@@ -6,6 +6,7 @@ import {
     forwardRef,
     Inject,
     Injectable,
+    Logger,
     NotFoundException,
     OnModuleInit
 } from '@nestjs/common';
@@ -13,17 +14,31 @@ import { JwtService } from '@nestjs/jwt';
 import { createWriteStream, promises as fs } from 'fs';
 import { basename, dirname } from 'path';
 import { pipeline } from 'stream/promises';
+import {
+    buildStorageConfigFromIntegration,
+    resolveFileProviderSlug,
+    resolveStorageEnumProvider,
+} from '../integration-profile/integration-profile.utils';
 import { SettingService } from '../setting/setting.service';
 import { DeleteDTO } from './dto/delete.dto';
 import { AbstractProvider } from './provider/abstract.provider';
-import { EnumProvider } from './provider/provider.enum';
 import { ProviderFactory } from './provider/provider.factory';
 
 @Injectable()
 export class FileService implements OnModuleInit {
-  private providerId: number;
+  private readonly logger = new Logger(FileService.name);
+  private providerId: number | undefined;
   private mimetypes: Record<string, number> = {};
 
+  private resolveProviderPath(file: { location: string; path: string }): string {
+    // Supports legacy basename-only values while prioritizing full provider keys.
+    if (typeof file.path === 'string' && file.path.includes('/')) {
+      return file.path;
+    }
+
+    return `${file.location}/${file.path}`;
+  }
+
   private hasMojibake(value: string): boolean {
     return /Ã.|Â.|â[\u0080-\u00BF]/.test(value);
   }
@@ -53,53 +68,60 @@ export class FileService implements OnModuleInit {
   ) { }
 
   async onModuleInit() {
-    await this.getProvider();
+    try {
+      await this.getProvider();
+    } catch (error) {
+      // No storage profile configured yet — server starts normally, uploads will
+      // fail until a profile is selected in Settings → File Storage.
+      this.logger.warn(
+        `Storage provider not ready on startup: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 
   async getProvider(): Promise<AbstractProvider> {
-    const settings = await this.settingService.getSettingValues([
-      'storage',
-      'storage-local-path',
-      'storage-s3-key',
-      'storage-s3-secret',
-      'storage-s3-region',
-      'storage-s3-bucket',
-      'storage-max-size',
-      'storage-accept-mimetype',
-      'storage-abs-account',
-      'storage-abs-key',
-      'storage-abs-container',
-      'storage-gcs-keyfile',
-    ]);
-
-    if (!settings['storage']) {
+    const settings = await this.settingService.getSettingValues(['file-storage-profile-id']);
+    const rawProfileId = settings['file-storage-profile-id'];
+    const profileId = Number(rawProfileId);
+
+    if (!Number.isFinite(profileId) || profileId <= 0) {
+      throw new BadRequestException('No file storage profile configured. Set a storage profile in the File Storage settings.');
+    }
+
+    const profile = await this.prismaService.integration_profile.findUnique({
+      where: { id: profileId },
+      include: {
+        integration_type: { select: { slug: true } },
+        integration_provider: { select: { slug: true } },
+      },
+    });
+
+    if (!profile) {
+      throw new NotFoundException(`Storage profile with id ${profileId} not found.`);
+    }
+
+    if (profile.integration_type.slug !== 'storage') {
       throw new BadRequestException(
-        `You must set the storage provider in the setting.`,
+        `Integration profile with id ${profileId} is not a storage profile.`,
       );
     }
 
-    const providerName = settings['storage'];
-    const provider = ProviderFactory.create(
-      providerName as EnumProvider,
-      settings,
-      this.jwtService,
-    );
+    const providerSlug = profile.integration_provider.slug;
+    const config = buildStorageConfigFromIntegration(providerSlug, profile.config);
+    const enumProvider = resolveStorageEnumProvider(providerSlug);
+    const fileProviderSlug = resolveFileProviderSlug(providerSlug);
 
     const providerData = await this.prismaService.file_provider.findFirst({
-      where: {
-        slug: providerName,
-      },
-      select: {
-        id: true,
-      },
+      where: { slug: fileProviderSlug },
+      select: { id: true },
     });
 
     if (!providerData) {
-      throw new BadRequestException(`Provider ${providerName} not found.`);
+      throw new BadRequestException(`Provider ${fileProviderSlug} not found.`);
     }
 
     this.providerId = providerData.id;
-    return provider;
+    return await ProviderFactory.create(enumProvider, config, this.jwtService);
   }
 
   async getMimeType(mimetype: string) {
@@ -130,58 +152,22 @@ export class FileService implements OnModuleInit {
   }
 
   async acceptMimetypes(mimetype: string) {
-
     if (!mimetype) {
       throw new BadRequestException(`No mimetype provided`);
     }
 
-    await this.getProvider();
-
-    const settings = await this.settingService.getSettingValues([
-      'storage',
-      'storage-local-path',
-      'storage-s3-key',
-      'storage-s3-secret',
-      'storage-s3-region',
-      'storage-s3-bucket',
-      'storage-max-size',
-      'storage-accept-mimetype',
-      'storage-abs-account',
-      'storage-abs-key',
-      'storage-abs-container',
-      'storage-gcs-keyfile',
-    ]);
-
+    const settings = await this.settingService.getSettingValues(['storage-accept-mimetype']);
     const acceptMimetypes = settings['storage-accept-mimetype'];
     return acceptMimetypes.indexOf(mimetype) !== -1;
   }
 
   async maxFileSize(size: number) {
-
     if (!size) {
       throw new BadRequestException(`No size provided`);
     }
 
-      await this.getProvider();
-    
-      const settings = await this.settingService.getSettingValues([
-      'storage',
-      'storage-local-path',
-      'storage-s3-key',
-      'storage-s3-secret',
-      'storage-s3-region',
-      'storage-s3-bucket',
-      'storage-max-size',
-      'storage-accept-mimetype',
-      'storage-abs-account',
-      'storage-abs-key',
-      'storage-abs-container',
-      'storage-gcs-keyfile',
-    ]);
-
-    const maxSize = settings['storage-max-size'];
-
-    return size <= Number(maxSize);
+    const settings = await this.settingService.getSettingValues(['storage-max-size']);
+    return size <= Number(settings['storage-max-size']);
   }
 
   async uploadFromString(
@@ -230,26 +216,6 @@ export class FileService implements OnModuleInit {
     return file;
   }
 
-  async getStorage() {
-    const settings = await this.settingService.getSettingValues([
-      'storage',
-    ]);
-
-    return settings['storage']; 
-  }
-
-  private getProviderPath(storage: string, filepath: string) {
-    if (storage === EnumProvider.LOCAL) {
-      return filepath;
-    }
-
-    try {
-      return new URL(filepath).pathname;
-    } catch {
-      return filepath;
-    }
-  }
-
   private mapStorageNotFoundError(error: any, fileId: number) {
     const missingInStorage =
       error?.name === 'NoSuchKey' ||
@@ -281,9 +247,8 @@ export class FileService implements OnModuleInit {
       throw new NotFoundException(`File not found: ${fileId}`);
     }
 
-    const storage = await this.getStorage();
     const provider = await this.getProvider();
-    const providerPath = this.getProviderPath(storage, file.path);
+    const providerPath = this.resolveProviderPath(file);
 
     let metadata: any;
     try {
@@ -364,11 +329,8 @@ export class FileService implements OnModuleInit {
       throw new NotFoundException(`File not found: ${fileId}`);
     }
     
-    const storage = await this.getStorage();
-
     const provider = await this.getProvider();
-
-    const providerPath = this.getProviderPath(storage, file.path);
+    const providerPath = this.resolveProviderPath(file);
 
     let providerBuffer: Buffer;
     try {
@@ -542,6 +504,7 @@ export class FileService implements OnModuleInit {
       },
       select: {
         id: true,
+        location: true,
         path: true,
       },
     });
@@ -551,7 +514,7 @@ export class FileService implements OnModuleInit {
     }
 
     for (const file of files) {
-      await (await this.getProvider()).delete(file.path);
+      await (await this.getProvider()).delete(this.resolveProviderPath(file));
 
       await this.prismaService.file.deleteMany({
         where: {
@@ -645,8 +608,9 @@ export class FileService implements OnModuleInit {
       }
 
       const provider = await this.getProvider();
-      const metadata = await provider.metaData(filepath);
-      const stream = await provider.readStream(filepath);
+      const providerPath = this.resolveProviderPath(file);
+      const metadata = await provider.metaData(providerPath);
+      const stream = await provider.readStream(providerPath);
       const size = this.getFileSizeFromMetadata(metadata);
       
       return {
@@ -674,9 +638,8 @@ export class FileService implements OnModuleInit {
       );
     }
 
-    const storage = await this.getStorage();
     const provider = await this.getProvider();
-    const providerPath = this.getProviderPath(storage, file.path);
+    const providerPath = this.resolveProviderPath(file);
     const metadata = await provider.metaData(providerPath);
     const stream = await provider.readStream(providerPath);
     const size = this.getFileSizeFromMetadata(metadata);

package/src/file/provider/azure.provider.ts

@@ -1,8 +1,8 @@
 import {
-  BlobServiceClient,
-  ContainerSASPermissions,
-  generateBlobSASQueryParameters,
-  StorageSharedKeyCredential,
+    BlobServiceClient,
+    ContainerSASPermissions,
+    generateBlobSASQueryParameters,
+    StorageSharedKeyCredential,
 } from '@azure/storage-blob';
 import { BadRequestException } from '@nestjs/common';
 import { basename } from 'path';
@@ -11,7 +11,6 @@ import { AbstractProvider } from './abstract.provider';
 export class AzureProvider extends AbstractProvider {
   constructor(private setting: Record<string, string>) {
     super();
-    this.initValidation();
   }
 
   async initValidation() {
@@ -68,13 +67,13 @@ export class AzureProvider extends AbstractProvider {
     const containerClient = blobServiceClient.getContainerClient(
       this.setting['storage-abs-container'],
     );
-    const filepath = [destination, this.getFilename(filename)].join('/');
-    const blobClient = containerClient.getBlockBlobClient(filepath);
+    const storedFilename = this.getFilename(filename);
+    const blobClient = containerClient.getBlockBlobClient([destination, storedFilename].join('/'));
 
     await blobClient.upload(fileContent, fileContent.length, {
       blobHTTPHeaders: { blobContentType: mimetype },
     });
-    return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
+    return storedFilename;
   }
 
   async upload(destination: string, file: MulterFile): Promise<any> {
@@ -82,15 +81,13 @@ export class AzureProvider extends AbstractProvider {
     const containerClient = blobServiceClient.getContainerClient(
       this.setting['storage-abs-container'],
     );
-    const filepath = [destination, this.getFilename(file.originalname)].join(
-      '/',
-    );
-    const blobClient = containerClient.getBlockBlobClient(filepath);
+    const storedFilename = this.getFilename(file.originalname);
+    const blobClient = containerClient.getBlockBlobClient([destination, storedFilename].join('/'));
 
     await blobClient.uploadData(file.buffer, {
       blobHTTPHeaders: { blobContentType: file.mimetype },
     });
-    return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
+    return storedFilename;
   }
 
   async uploadFromPath(
@@ -102,10 +99,8 @@ export class AzureProvider extends AbstractProvider {
     const containerClient = blobServiceClient.getContainerClient(
       this.setting['storage-abs-container'],
     );
-    const filepath = [destination, this.getFilename(options?.filename ?? basename(filePath))].join(
-      '/',
-    );
-    const blobClient = containerClient.getBlockBlobClient(filepath);
+    const storedFilename = this.getFilename(options?.filename ?? basename(filePath));
+    const blobClient = containerClient.getBlockBlobClient([destination, storedFilename].join('/'));
 
     await blobClient.uploadFile(filePath, {
       blobHTTPHeaders: options?.mimetype
@@ -113,24 +108,15 @@ export class AzureProvider extends AbstractProvider {
         : undefined,
     });
 
-    return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
+    return storedFilename;
   }
 
   async delete(filepath: string): Promise<any> {
-    const url = new URL(filepath);
-
-    if (!url.pathname) {
-      throw new Error(`Invalid filepath "${filepath}" for S3`);
-    }
-
     const blobServiceClient = await this.getClient();
     const containerClient = blobServiceClient.getContainerClient(
       this.setting['storage-abs-container'],
     );
-    const blobClient = containerClient.getBlockBlobClient(
-      url.pathname.split('/').slice(1).join('/'),
-    );
-
+    const blobClient = containerClient.getBlockBlobClient(filepath);
     return await blobClient.delete();
   }
 

package/src/file/provider/gcs.provider.ts

@@ -8,7 +8,6 @@ export class GCSProvider extends AbstractProvider {
 
   constructor(private setting: Record<string, string>) {
     super();
-    this.initValidation();
   }
 
   async initValidation() {
@@ -53,20 +52,21 @@ export class GCSProvider extends AbstractProvider {
   ): Promise<any> {
     const storage = await this.getClient();
     const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
-    const file = bucket.file(destination + filename);
+    const storedFilename = this.getFilename(filename);
+    const file = bucket.file([destination, storedFilename].join('/'));
 
-    return file.save(fileContent, {
-      contentType: mimetype,
-    });
+    await file.save(fileContent, { contentType: mimetype });
+    return storedFilename;
   }
+
   async upload(destination: string, file: MulterFile): Promise<any> {
     const storage = await this.getClient();
     const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
-    const fileObject = bucket.file(destination + file.originalname);
+    const storedFilename = this.getFilename(file.originalname);
+    const fileObject = bucket.file([destination, storedFilename].join('/'));
 
-    return fileObject.save(file.buffer, {
-      contentType: file.mimetype,
-    });
+    await fileObject.save(file.buffer, { contentType: file.mimetype });
+    return storedFilename;
   }
 
   async uploadFromPath(

package/src/file/provider/local.provider.ts

@@ -13,7 +13,6 @@ export class LocalProvider extends AbstractProvider {
     private jwt: JwtService
   ) {
     super();
-    this.initValidation();
   }
 
   async initValidation() {
@@ -40,7 +39,8 @@ export class LocalProvider extends AbstractProvider {
   }
 
   private resolveFilepath(filepath: string): string {
-    return path.isAbsolute(filepath) ? filepath : path.resolve(filepath);
+    if (path.isAbsolute(filepath)) return filepath;
+    return join(this.setting['storage-local-path'], filepath);
   }
 
   async uploadFromString(
@@ -67,11 +67,12 @@ export class LocalProvider extends AbstractProvider {
       );
     }
 
-    const filePath = join(storagePath, this.getFilename(filename));
+    const storedFilename = this.getFilename(filename);
+    const filePath = join(storagePath, storedFilename);
 
     await writeFile(filePath, fileContent);
 
-    return filePath;
+    return storedFilename;
   }
 
   async upload(destination: string, file: MulterFile): Promise<any> {
@@ -92,11 +93,9 @@ export class LocalProvider extends AbstractProvider {
         `The storage path does not exist: ${storagePath}`,
       );
     }
-    const filePath = join(storagePath, this.getFilename(file.originalname));
-
-    await writeFile(filePath, file.buffer);
-
-    return filePath;
+    const storedFilename = this.getFilename(file.originalname);
+    await writeFile(join(storagePath, storedFilename), file.buffer);
+    return storedFilename;
   }
 
   async uploadFromPath(
@@ -121,10 +120,8 @@ export class LocalProvider extends AbstractProvider {
     }
 
     const targetFilename = this.getFilename(options?.filename ?? basename(sourcePath));
-    const targetPath = join(storagePath, targetFilename);
-    await copyFile(sourcePath, targetPath);
-
-    return targetPath;
+    await copyFile(sourcePath, join(storagePath, targetFilename));
+    return targetFilename;
   }
 
   async delete(filepath: string): Promise<any> {

package/src/file/provider/provider.enum.ts

@@ -3,4 +3,5 @@ export enum EnumProvider {
   LOCAL = 'local',
   AZURE = 'abs',
   GCS = 'gcs',
+  SPACES = 'spaces',
 }

package/src/file/provider/provider.factory.ts

@@ -5,22 +5,37 @@ import { GCSProvider } from './gcs.provider';
 import { LocalProvider } from './local.provider';
 import { EnumProvider } from './provider.enum';
 import { S3Provider } from './s3.provider';
+import { SpacesProvider } from './spaces.provider';
 
 export class ProviderFactory {
-  static create(
+  static async create(
     providerType: EnumProvider,
     setting: Record<string, string>,
     jwtService: JwtService,
-  ): AbstractProvider {
+  ): Promise<AbstractProvider> {
+    let provider: AbstractProvider;
+
     switch (providerType) {
       case EnumProvider.S3:
-        return new S3Provider(setting);
+        provider = new S3Provider(setting);
+        break;
       case EnumProvider.LOCAL:
-        return new LocalProvider(setting, jwtService);
+        provider = new LocalProvider(setting, jwtService);
+        break;
       case EnumProvider.AZURE:
-        return new AzureProvider(setting);
+        provider = new AzureProvider(setting);
+        break;
       case EnumProvider.GCS:
-        return new GCSProvider(setting);
+        provider = new GCSProvider(setting);
+        break;
+      case EnumProvider.SPACES:
+        provider = new SpacesProvider(setting);
+        break;
+      default:
+        throw new Error(`Unsupported provider type: ${providerType}`);
     }
+
+    await provider.initValidation();
+    return provider;
   }
 }

package/src/file/provider/s3.provider.ts

@@ -20,28 +20,13 @@ export class S3Provider extends AbstractProvider {
 
   constructor(private setting: Record<string, string>) {
     super();
-    this.initValidation();
   }
 
   private resolveS3Key(filepath: string): string {
     if (!filepath) {
       throw new Error('Invalid filepath for S3');
     }
-
-    try {
-      const url = new URL(filepath);
-      const keyFromUrl = url.pathname.split('/').filter(Boolean).join('/');
-      if (!keyFromUrl) {
-        throw new Error(`Invalid filepath "${filepath}" for S3`);
-      }
-      return keyFromUrl;
-    } catch {
-      const keyFromPath = filepath.split('/').filter(Boolean).join('/');
-      if (!keyFromPath) {
-        throw new Error(`Invalid filepath "${filepath}" for S3`);
-      }
-      return keyFromPath;
-    }
+    return filepath;
   }
 
   async buffer(filepath: string): Promise<Buffer> {
@@ -151,8 +136,7 @@ export class S3Provider extends AbstractProvider {
       Body: fileContent,
     });
     await s3.send(command);
-    // S3 v3 não retorna Location diretamente, construa a URL:
-    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
+    return storedFilename;
   }
 
   async upload(destination: string, file: MulterFile): Promise<any> {
@@ -165,7 +149,7 @@ export class S3Provider extends AbstractProvider {
       Body: file.buffer,
     });
     await s3.send(command);
-    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
+    return storedFilename;
   }
 
   async uploadFromPath(
@@ -185,7 +169,7 @@ export class S3Provider extends AbstractProvider {
     });
 
     await s3.send(command);
-    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${key}`;
+    return storedFilename;
   }
 
   async delete(filepath: string): Promise<any> {