@hed-hog/core 0.0.360 → 0.0.362

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';