@hed-hog/core 0.0.361 → 0.0.364

package/src/auth/guards/auth.guard.ts

@@ -5,6 +5,7 @@ import {
   CanActivate,
   ExecutionContext,
   Injectable,
+  Logger,
   UnauthorizedException,
 } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
@@ -14,6 +15,8 @@ import { TokenService } from '../../token/token.service';
 
 @Injectable()
 export class AuthGuard implements CanActivate {
+  private readonly logger = new Logger(AuthGuard.name);
+
   constructor(
     private token: TokenService,
     private reflector: Reflector,
@@ -50,23 +53,26 @@ export class AuthGuard implements CanActivate {
       if (isPublic) {
         return true;
       } else if (withNoRole) {
+        this.logger.debug(`[AuthGuard] No token: ${request.method} ${request.url}`);
         // @NoRole() requires authentication but no specific role — token is mandatory
         throw new UnauthorizedException(
           getLocaleText('accessDenied', locale, 'Access denied.'),
         );
       } else if (withRole) {
+        this.logger.debug(`[AuthGuard] No token: ${request.method} ${request.url}`);
         // @Role() decorator requires authentication
         throw new UnauthorizedException(
           getLocaleText('accessDenied', locale, 'Access denied.'),
         );
       } else {
+        this.logger.debug(`[AuthGuard] No token: ${request.method} ${request.url}`);
         // No explicit decorator, default behavior (deny)
         throw new UnauthorizedException(
           getLocaleText('accessDenied', locale, 'Access denied.'),
         );
       }
     }
-    
+
     try {
       const payload = await this.token.verify(locale, token);
 
@@ -75,8 +81,9 @@ export class AuthGuard implements CanActivate {
       if (isPublic) {
         return true;
       } else {
-        // Return proper 401 status with clear message for JWT errors
-        const message = (error as any)?.message || (error as any)?.name || 'Unauthorized';
+        const errName = (error as any)?.name ?? 'UnknownError';
+        const message = (error as any)?.message || errName || 'Unauthorized';
+        this.logger.warn(`[AuthGuard] Token rejected ${request.method} ${request.url} error=${errName}: ${message}`);
         throw new UnauthorizedException(message);
       }
     }

package/src/file/file.module.ts

@@ -5,6 +5,7 @@ import { JwtModule } from '@nestjs/jwt';
 import { SettingModule } from '../setting/setting.module';
 import { FileController } from './file.controller';
 import { FileService } from './file.service';
+import { ImageOptimizationService } from './image-optimization.service';
 
 @Module({
   imports: [
@@ -15,8 +16,8 @@ import { FileService } from './file.service';
       JwtModule,
     ),
   ],
-  providers: [FileService],
-  exports: [FileService],
+  providers: [FileService, ImageOptimizationService],
+  exports: [FileService, ImageOptimizationService],
   controllers: [FileController],
 })
 export class FileModule { }

package/src/file/file.service.ts

@@ -1,4 +1,17 @@
-import { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import {
+  GetBucketNotificationConfigurationCommand,
+  HeadBucketCommand,
+  HeadObjectCommand,
+  PutBucketNotificationConfigurationCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import {
+  AddPermissionCommand,
+  CreateFunctionCommand,
+  GetFunctionConfigurationCommand,
+  LambdaClient,
+  UpdateFunctionConfigurationCommand,
+} from '@aws-sdk/client-lambda';
 import {
   AssumeRoleCommand,
   GetSessionTokenCommand,
@@ -8,25 +21,26 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-    BadRequestException,
-    forwardRef,
-    Inject,
-    Injectable,
-    Logger,
-    NotFoundException,
-    OnModuleInit
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
+  OnModuleInit
 } from '@nestjs/common';
 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,
+  buildStorageConfigFromIntegration,
+  resolveFileProviderSlug,
+  resolveStorageEnumProvider,
 } from '../integration-profile/integration-profile.utils';
 import { SettingService } from '../setting/setting.service';
 import { DeleteDTO } from './dto/delete.dto';
+import { ImageOptimizationService } from './image-optimization.service';
 import { AbstractProvider } from './provider/abstract.provider';
 import { ProviderFactory } from './provider/provider.factory';
 
@@ -71,6 +85,8 @@ export class FileService implements OnModuleInit {
     private readonly settingService: SettingService,
     @Inject(forwardRef(() => JwtService))
     private readonly jwtService: JwtService,
+    @Inject(forwardRef(() => ImageOptimizationService))
+    private readonly imageOptimizationService: ImageOptimizationService,
   ) { }
 
   async onModuleInit() {
@@ -397,21 +413,30 @@ export class FileService implements OnModuleInit {
       fileBuffer.originalname,
     );
 
+    const optimized = await this.imageOptimizationService.optimizeBuffer(
+      fileBuffer.buffer,
+      fileBuffer.mimetype,
+      normalizedFilename,
+    );
+
     const normalizedFile = {
       ...fileBuffer,
-      originalname: normalizedFilename,
+      buffer: optimized.buffer,
+      mimetype: optimized.mimetype,
+      originalname: optimized.originalname,
+      size: optimized.buffer.length,
     };
 
     const url = await provider.upload(destination, normalizedFile);
 
     const file = await this.prismaService.file.create({
       data: {
-        filename: normalizedFilename,
+        filename: optimized.originalname,
         path: url,
         provider_id: this.providerId,
         location: destination,
-        mimetype_id: await this.getMimeType(fileBuffer.mimetype),
-        size: fileBuffer.size,
+        mimetype_id: await this.getMimeType(optimized.mimetype),
+        size: optimized.buffer.length,
       },
     });
 
@@ -456,45 +481,35 @@ export class FileService implements OnModuleInit {
       throw new BadRequestException(`File too large: ${size} bytes`);
     }
 
-    const provider = await this.getProvider();
-    const providerWithPathUpload = provider as AbstractProvider & {
-      uploadFromPath?: (
-        destination: string,
-        filePath: string,
-        options?: { filename?: string; mimetype?: string },
-      ) => Promise<string>;
-    };
+    // Read buffer to allow image optimization regardless of provider support
+    const rawBuffer = await fs.readFile(filePath);
+    const optimized = await this.imageOptimizationService.optimizeBuffer(
+      rawBuffer,
+      mimetype,
+      originalname,
+    );
 
-    let url: string;
-    if (typeof providerWithPathUpload.uploadFromPath === 'function') {
-      url = await providerWithPathUpload.uploadFromPath(destination, filePath, {
-        filename: originalname,
-        mimetype,
-      });
-    } else {
-      // Fallback explícito para providers legados sem suporte nativo por path.
-      const buffer = await fs.readFile(filePath);
-      url = await provider.upload(destination, {
-        fieldname: 'file',
-        originalname,
-        encoding: metadata?.encoding ?? '7bit',
-        mimetype,
-        size,
-        destination: '',
-        filename: originalname,
-        path: filePath,
-        buffer,
-      });
-    }
+    const provider = await this.getProvider();
+    const url = await provider.upload(destination, {
+      fieldname: 'file',
+      originalname: optimized.originalname,
+      encoding: metadata?.encoding ?? '7bit',
+      mimetype: optimized.mimetype,
+      size: optimized.buffer.length,
+      destination: '',
+      filename: optimized.originalname,
+      path: filePath,
+      buffer: optimized.buffer,
+    });
 
     const file = await this.prismaService.file.create({
       data: {
-        filename: originalname,
+        filename: optimized.originalname,
         path: url,
         provider_id: this.providerId,
         location: destination,
-        mimetype_id: await this.getMimeType(mimetype),
-        size,
+        mimetype_id: await this.getMimeType(optimized.mimetype),
+        size: optimized.buffer.length,
       },
     });
 
@@ -754,6 +769,305 @@ export class FileService implements OnModuleInit {
     };
   }
 
+  async headS3Bucket(params: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    region: string;
+    bucket: string;
+  }): Promise<void> {
+    const s3 = new S3Client({
+      region: params.region,
+      credentials: {
+        accessKeyId: params.accessKeyId,
+        secretAccessKey: params.secretAccessKey,
+        ...(params.sessionToken ? { sessionToken: params.sessionToken } : {}),
+      },
+    });
+
+    await s3.send(new HeadBucketCommand({ Bucket: params.bucket }));
+  }
+
+  async getLambdaFunctionConfiguration(params: {
+    functionName: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+  }) {
+    const lambda = new LambdaClient({
+      region: params.region,
+      credentials: {
+        accessKeyId: params.accessKeyId,
+        secretAccessKey: params.secretAccessKey,
+        ...(params.sessionToken ? { sessionToken: params.sessionToken } : {}),
+      },
+    });
+
+    return lambda.send(
+      new GetFunctionConfigurationCommand({
+        FunctionName: params.functionName,
+      }),
+    );
+  }
+
+  async updateLambdaEnvironmentVariables(params: {
+    functionName: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    environmentVariables: Record<string, string>;
+  }) {
+    const lambda = new LambdaClient({
+      region: params.region,
+      credentials: {
+        accessKeyId: params.accessKeyId,
+        secretAccessKey: params.secretAccessKey,
+        ...(params.sessionToken ? { sessionToken: params.sessionToken } : {}),
+      },
+    });
+
+    const current = await lambda.send(
+      new GetFunctionConfigurationCommand({
+        FunctionName: params.functionName,
+      }),
+    );
+
+    const merged = {
+      ...(current.Environment?.Variables ?? {}),
+      ...params.environmentVariables,
+    };
+
+    await lambda.send(
+      new UpdateFunctionConfigurationCommand({
+        FunctionName: params.functionName,
+        Environment: {
+          Variables: merged,
+        },
+      }),
+    );
+
+    return {
+      functionName: current.FunctionName ?? params.functionName,
+      functionArn: current.FunctionArn ?? null,
+    };
+  }
+
+  async createLambdaFunctionIfMissing(params: {
+    functionName: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    roleArn: string;
+    packageType: 'Image' | 'Zip';
+    imageUri?: string;
+    zipFile?: Uint8Array;
+    s3Bucket?: string;
+    s3Key?: string;
+    s3ObjectVersion?: string;
+    handler?: string;
+    runtime?: string;
+    timeout?: number;
+    memorySize?: number;
+    environmentVariables?: Record<string, string>;
+  }) {
+    const lambda = new LambdaClient({
+      region: params.region,
+      credentials: {
+        accessKeyId: params.accessKeyId,
+        secretAccessKey: params.secretAccessKey,
+        ...(params.sessionToken ? { sessionToken: params.sessionToken } : {}),
+      },
+    });
+
+    try {
+      const existing = await lambda.send(
+        new GetFunctionConfigurationCommand({
+          FunctionName: params.functionName,
+        }),
+      );
+
+      return {
+        created: false,
+        functionName: existing.FunctionName ?? params.functionName,
+        functionArn: existing.FunctionArn ?? null,
+      };
+    } catch (error: any) {
+      if (String(error?.name ?? '') !== 'ResourceNotFoundException') {
+        throw error;
+      }
+    }
+
+    const baseInput = {
+      FunctionName: params.functionName,
+      Role: params.roleArn,
+      PackageType: params.packageType,
+      Timeout: params.timeout,
+      MemorySize: params.memorySize,
+      Environment: params.environmentVariables
+        ? {
+            Variables: params.environmentVariables,
+          }
+        : undefined,
+    } as const;
+
+    const created =
+      params.packageType === 'Image'
+        ? await lambda.send(
+            new CreateFunctionCommand({
+              ...baseInput,
+              Code: {
+                ImageUri: params.imageUri,
+              },
+            }),
+          )
+        : await lambda.send(
+            new CreateFunctionCommand({
+              ...baseInput,
+              Handler: params.handler,
+              Runtime: params.runtime as any,
+              Code: {
+                ...(params.zipFile
+                  ? {
+                      ZipFile: params.zipFile,
+                    }
+                  : {
+                      S3Bucket: params.s3Bucket,
+                      S3Key: params.s3Key,
+                      ...(params.s3ObjectVersion
+                        ? {
+                            S3ObjectVersion: params.s3ObjectVersion,
+                          }
+                        : {}),
+                    }),
+              },
+            }),
+          );
+
+    return {
+      created: true,
+      functionName: created.FunctionName ?? params.functionName,
+      functionArn: created.FunctionArn ?? null,
+    };
+  }
+
+  async allowS3InvokeLambda(params: {
+    functionName: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    bucketName: string;
+    sourceAccount?: string;
+    statementId?: string;
+  }) {
+    const lambda = new LambdaClient({
+      region: params.region,
+      credentials: {
+        accessKeyId: params.accessKeyId,
+        secretAccessKey: params.secretAccessKey,
+        ...(params.sessionToken ? { sessionToken: params.sessionToken } : {}),
+      },
+    });
+
+    const statementId =
+      params.statementId ?? `lms-bulk-upload-${params.bucketName.replace(/[^a-zA-Z0-9-_]/g, '-')}`;
+
+    try {
+      await lambda.send(
+        new AddPermissionCommand({
+          FunctionName: params.functionName,
+          StatementId: statementId.slice(0, 100),
+          Action: 'lambda:InvokeFunction',
+          Principal: 's3.amazonaws.com',
+          SourceArn: `arn:aws:s3:::${params.bucketName}`,
+          ...(params.sourceAccount
+            ? {
+                SourceAccount: params.sourceAccount,
+              }
+            : {}),
+        }),
+      );
+    } catch (error: any) {
+      if (String(error?.name ?? '') === 'ResourceConflictException') {
+        return;
+      }
+
+      throw error;
+    }
+  }
+
+  async configureS3BucketLambdaNotification(params: {
+    bucketName: string;
+    lambdaArn: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    configurationId?: string;
+    prefix?: string;
+  }) {
+    const s3 = new S3Client({
+      region: params.region,
+      credentials: {
+        accessKeyId: params.accessKeyId,
+        secretAccessKey: params.secretAccessKey,
+        ...(params.sessionToken ? { sessionToken: params.sessionToken } : {}),
+      },
+    });
+
+    const configurationId =
+      params.configurationId ?? 'lms-bulk-upload-object-created';
+
+    const existing = await s3.send(
+      new GetBucketNotificationConfigurationCommand({
+        Bucket: params.bucketName,
+      }),
+    );
+
+    const lambdaConfigurations = Array.isArray(existing?.LambdaFunctionConfigurations)
+      ? existing.LambdaFunctionConfigurations.filter((cfg: any) => cfg?.Id !== configurationId)
+      : [];
+
+    lambdaConfigurations.push({
+      Id: configurationId,
+      LambdaFunctionArn: params.lambdaArn,
+      Events: ['s3:ObjectCreated:*'],
+      ...(params.prefix
+        ? {
+            Filter: {
+              Key: {
+                FilterRules: [
+                  {
+                    Name: 'prefix',
+                    Value: params.prefix,
+                  },
+                ],
+              },
+            },
+          }
+        : {}),
+    });
+
+    await s3.send(
+      new PutBucketNotificationConfigurationCommand({
+        Bucket: params.bucketName,
+        NotificationConfiguration: {
+          TopicConfigurations: Array.isArray(existing?.TopicConfigurations)
+            ? existing.TopicConfigurations
+            : [],
+          QueueConfigurations: Array.isArray(existing?.QueueConfigurations)
+            ? existing.QueueConfigurations
+            : [],
+          EventBridgeConfiguration: existing?.EventBridgeConfiguration,
+          LambdaFunctionConfigurations: lambdaConfigurations,
+        },
+      }),
+    );
+  }
+
   createDownloadToken(filepath: string, expires = 3600) {
     if (!filepath) {
       throw new BadRequestException(`No file path provided`);

package/src/file/image-optimization.service.ts

@@ -0,0 +1,123 @@
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { basename, extname } from 'path';
+import sharp from 'sharp';
+import { SettingService } from '../setting/setting.service';
+
+export interface OptimizedImage {
+  buffer: Buffer;
+  mimetype: string;
+  originalname: string;
+}
+
+@Injectable()
+export class ImageOptimizationService {
+  private readonly logger = new Logger(ImageOptimizationService.name);
+
+  constructor(
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+  ) {}
+
+  private parseArraySetting(raw: string | undefined): string[] {
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+
+  private replaceExtension(filename: string, newExt: string): string {
+    const base = basename(filename, extname(filename));
+    return `${base}.${newExt}`;
+  }
+
+  /**
+   * Applies image compression and/or WebP conversion to the given buffer
+   * based on the current settings. Returns the original data unchanged if
+   * the settings are disabled or the MIME type is not in the configured lists.
+   */
+  async optimizeBuffer(
+    buffer: Buffer,
+    mimetype: string,
+    originalname: string,
+  ): Promise<OptimizedImage> {
+    if (!mimetype.startsWith('image/')) {
+      return { buffer, mimetype, originalname };
+    }
+
+    const settings = await this.settingService.getSettingValues([
+      'image-compression-enabled',
+      'image-compression-quality',
+      'image-compression-types',
+      'image-webp-conversion-enabled',
+      'image-webp-convert-types',
+    ]);
+
+    const compressionEnabled = settings['image-compression-enabled'] === 'true';
+    const webpEnabled = settings['image-webp-conversion-enabled'] === 'true';
+
+    if (!compressionEnabled && !webpEnabled) {
+      return { buffer, mimetype, originalname };
+    }
+
+    const quality = Math.min(
+      100,
+      Math.max(1, Number(settings['image-compression-quality']) || 80),
+    );
+    const compressionTypes = this.parseArraySetting(settings['image-compression-types']);
+    const webpConvertTypes = this.parseArraySetting(settings['image-webp-convert-types']);
+
+    // WebP conversion has priority over plain compression
+    if (webpEnabled && webpConvertTypes.includes(mimetype)) {
+      try {
+        const optimized = await sharp(buffer).webp({ quality }).toBuffer();
+        return {
+          buffer: optimized,
+          mimetype: 'image/webp',
+          originalname: this.replaceExtension(originalname, 'webp'),
+        };
+      } catch (err) {
+        this.logger.warn(
+          `WebP conversion failed for "${originalname}" (${mimetype}): ${err instanceof Error ? err.message : String(err)}. Falling back to original.`,
+        );
+        return { buffer, mimetype, originalname };
+      }
+    }
+
+    if (compressionEnabled && compressionTypes.includes(mimetype)) {
+      try {
+        let instance = sharp(buffer);
+        if (mimetype === 'image/jpeg') {
+          instance = instance.jpeg({ quality });
+        } else if (mimetype === 'image/png') {
+          // sharp compressionLevel is 0-9 (9 = max); invert from quality scale
+          const compressionLevel = Math.round(((100 - quality) / 100) * 9);
+          instance = instance.png({ compressionLevel });
+        } else if (mimetype === 'image/webp') {
+          instance = instance.webp({ quality });
+        } else if (mimetype === 'image/bmp' || mimetype === 'image/tiff') {
+          // Convert to PNG as a compressed lossless alternative
+          instance = instance.png({ compressionLevel: Math.round(((100 - quality) / 100) * 9) });
+          return {
+            buffer: await instance.toBuffer(),
+            mimetype: 'image/png',
+            originalname: this.replaceExtension(originalname, 'png'),
+          };
+        } else {
+          return { buffer, mimetype, originalname };
+        }
+        const optimized = await instance.toBuffer();
+        return { buffer: optimized, mimetype, originalname };
+      } catch (err) {
+        this.logger.warn(
+          `Image compression failed for "${originalname}" (${mimetype}): ${err instanceof Error ? err.message : String(err)}. Falling back to original.`,
+        );
+        return { buffer, mimetype, originalname };
+      }
+    }
+
+    return { buffer, mimetype, originalname };
+  }
+}

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

@@ -27,15 +27,8 @@ export class LocalProvider extends AbstractProvider {
     }
   }
 
-  async createFolderRecursive(path: string) {
-    const folders = join(path).split(sep);
-    let currentPath = '';
-    for (const folder of folders) {
-      currentPath = join(currentPath, folder);
-      if (!existsSync(currentPath)) {
-        await mkdir(currentPath, { recursive: true });
-      }
-    }
+  async createFolderRecursive(folderPath: string): Promise<void> {
+    await mkdir(folderPath, { recursive: true });
   }
 
   private resolveFilepath(filepath: string): string {

package/src/index.ts

@@ -39,6 +39,7 @@ export * from './ai/ai.service';
 
 export * from './webhook-integration/event-webhook.service';
 export * from './webhook-integration/integration-event-catalog.service';
+export * from './webhook-integration/webhook-command.registry';
 export * from './webhook-integration/webhook-integration.module';
 export * from './webhook-integration/webhook-integration.service';