@hed-hog/core 0.0.356 → 0.0.359

package/src/file/file.service.ts

@@ -6,6 +6,7 @@ import {
     forwardRef,
     Inject,
     Injectable,
+    Logger,
     NotFoundException,
     OnModuleInit
 } from '@nestjs/common';
@@ -14,21 +15,30 @@ import { createWriteStream, promises as fs } from 'fs';
 import { basename, dirname } from 'path';
 import { pipeline } from 'stream/promises';
 import {
-  buildStorageConfigFromIntegration,
-  resolveFileProviderSlug,
-  resolveStorageEnumProvider,
+    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);
   }
@@ -60,17 +70,21 @@ export class FileService implements OnModuleInit {
   async onModuleInit() {
     try {
       await this.getProvider();
-    } catch {
+    } 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(['file-storage-profile-id']);
-    const profileId = Number(settings['file-storage-profile-id']);
+    const rawProfileId = settings['file-storage-profile-id'];
+    const profileId = Number(rawProfileId);
 
-    if (!profileId) {
+    if (!Number.isFinite(profileId) || profileId <= 0) {
       throw new BadRequestException('No file storage profile configured. Set a storage profile in the File Storage settings.');
     }
 
@@ -107,7 +121,7 @@ export class FileService implements OnModuleInit {
     }
 
     this.providerId = providerData.id;
-    return ProviderFactory.create(enumProvider, config, this.jwtService);
+    return await ProviderFactory.create(enumProvider, config, this.jwtService);
   }
 
   async getMimeType(mimetype: string) {
@@ -202,38 +216,6 @@ export class FileService implements OnModuleInit {
     return file;
   }
 
-  async getStorage(): Promise<string> {
-    const settings = await this.settingService.getSettingValues(['file-storage-profile-id']);
-    const profileId = Number(settings['file-storage-profile-id']);
-
-    if (!profileId) {
-      return EnumProvider.LOCAL;
-    }
-
-    const profile = await this.prismaService.integration_profile.findUnique({
-      where: { id: profileId },
-      include: { integration_provider: { select: { slug: true } } },
-    });
-
-    if (!profile) {
-      return EnumProvider.LOCAL;
-    }
-
-    return resolveStorageEnumProvider(profile.integration_provider.slug);
-  }
-
-  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' ||
@@ -265,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 {
@@ -348,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 {
@@ -526,6 +504,7 @@ export class FileService implements OnModuleInit {
       },
       select: {
         id: true,
+        location: true,
         path: true,
       },
     });
@@ -535,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: {
@@ -629,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 {
@@ -658,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.factory.ts

@@ -8,22 +8,34 @@ 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:
-        return new SpacesProvider(setting);
+        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> {

package/src/file/provider/spaces.provider.ts

@@ -20,7 +20,6 @@ export class SpacesProvider extends AbstractProvider {
 
   constructor(private setting: Record<string, string>) {
     super();
-    this.initValidation();
   }
 
   private get endpoint() {
@@ -39,21 +38,7 @@ export class SpacesProvider extends AbstractProvider {
     if (!filepath) {
       throw new Error('Invalid filepath for DigitalOcean Spaces');
     }
-
-    try {
-      const url = new URL(filepath);
-      const key = url.pathname.split('/').filter(Boolean).join('/');
-      if (!key) {
-        throw new Error(`Invalid filepath "${filepath}" for DigitalOcean Spaces`);
-      }
-      return key;
-    } catch {
-      const key = filepath.split('/').filter(Boolean).join('/');
-      if (!key) {
-        throw new Error(`Invalid filepath "${filepath}" for DigitalOcean Spaces`);
-      }
-      return key;
-    }
+    return filepath;
   }
 
   async initValidation() {
@@ -169,7 +154,7 @@ export class SpacesProvider extends AbstractProvider {
         ACL: 'public-read',
       }),
     );
-    return `${this.bucketUrl}/${key}`;
+    return storedFilename;
   }
 
   async uploadFromString(
@@ -188,7 +173,7 @@ export class SpacesProvider extends AbstractProvider {
         ACL: 'public-read',
       }),
     );
-    return `${this.bucketUrl}/${key}`;
+    return storedFilename;
   }
 
   async uploadFromPath(
@@ -209,7 +194,7 @@ export class SpacesProvider extends AbstractProvider {
         ACL: 'public-read',
       }),
     );
-    return `${this.bucketUrl}/${key}`;
+    return storedFilename;
   }
 
   async delete(filepath: string): Promise<any> {

package/src/integration-profile/integration-profile.controller.ts

@@ -54,11 +54,13 @@ export class IntegrationProfileController {
     @Pagination() paginationParams,
     @Query('typeId') typeId?: string,
     @Query('typeSlug') typeSlug?: string,
+    @Query('providerSlug') providerSlug?: string,
   ) {
     return this.integrationProfileService.list(
       paginationParams,
       typeId ? parseInt(typeId, 10) : undefined,
       typeSlug,
+      providerSlug,
     );
   }
 

package/src/integration-profile/integration-profile.service.ts

@@ -100,10 +100,12 @@ export class IntegrationProfileService {
     paginationParams: PaginationDTO,
     typeId?: number,
     typeSlug?: string,
+    providerSlug?: string,
   ) {
     const fields = ['slug', 'name'];
     const OR = this.prismaService.createInsensitiveSearch(fields, paginationParams);
     const normalizedTypeSlug = String(typeSlug ?? '').trim();
+    const normalizedProviderSlug = String(providerSlug ?? '').trim();
 
     const result = await this.paginationService.paginate(
       this.prismaService.integration_profile,
@@ -115,6 +117,9 @@ export class IntegrationProfileService {
           ...(normalizedTypeSlug
             ? { integration_type: { slug: normalizedTypeSlug } }
             : {}),
+          ...(normalizedProviderSlug
+            ? { integration_provider: { slug: normalizedProviderSlug } }
+            : {}),
         },
         select: {
           id: true,
@@ -157,8 +162,8 @@ export class IntegrationProfileService {
         SELECT
           ip.id,
           (
-            COALESCE((SELECT COUNT(*)::int FROM campaign       WHERE mail_profile_id = ip.id), 0) +
-            COALESCE((SELECT COUNT(*)::int FROM webhook_action WHERE mail_profile_id = ip.id), 0)
+            COALESCE((SELECT COUNT(*)::int FROM campaign       WHERE integration_profile_id = ip.id), 0) +
+            COALESCE((SELECT COUNT(*)::int FROM webhook_action WHERE integration_profile_id = ip.id), 0)
           ) AS uses_count
         FROM integration_profile ip
         WHERE ip.id = ANY(${ids}::int[])

package/src/integration-profile/integration-profile.utils.ts

@@ -135,6 +135,23 @@ export function resolveFileProviderSlug(providerSlug: string): string {
 
 // ─── AI utilities ─────────────────────────────────────────────────────────────
 
+// ─── OAuth utilities ──────────────────────────────────────────────────────────
+
+/** Maps an integration_profile config JSON to OAuth client credentials. */
+export function buildOAuthConfigFromIntegration(
+  _providerSlug: string,
+  config: unknown,
+): { clientId: string; clientSecret: string; tenantId?: string } {
+  const cfg = (config as Cfg) ?? {};
+  return {
+    clientId: String(cfg.client_id ?? ''),
+    clientSecret: String(cfg.client_secret ?? ''),
+    ...(cfg.tenant_id ? { tenantId: String(cfg.tenant_id) } : {}),
+  };
+}
+
+// ─── AI utilities ─────────────────────────────────────────────────────────────
+
 /** Maps an integration_profile config JSON to the API key and optional org needed by AI providers. */
 export function buildAiConfigFromIntegration(
   providerSlug: string,

package/src/mail/mail.module.ts

@@ -15,12 +15,22 @@ import { MailService } from './mail.service';
       inject: [PrismaService],
       useFactory: async (prisma: PrismaService) => {
         try {
-          const profileIdSetting = await prisma.setting.findUnique({
-            where: { slug: 'mail-profile-id' },
-            select: { value: true },
+          const profileSettings = await prisma.setting.findMany({
+            where: {
+              slug: {
+                in: ['mail-integration-profile-id'],
+              },
+            },
+            select: { slug: true, value: true },
           });
 
-          const profileId = Number(profileIdSetting?.value);
+          const profileSettingsMap = new Map(
+            profileSettings.map((item) => [item.slug, item.value]),
+          );
+
+          const profileId = Number(
+            profileSettingsMap.get('mail-integration-profile-id'),
+          );
 
           if (!profileId || profileId <= 0) {
             return { global: true, type: 'SMTP', host: 'localhost', port: 1025, secure: false, username: '', password: '' } as MailModuleOptions;