@nest-omni/core 4.1.3-2 → 4.1.3-20

package/file-upload/processors/image.processor.d.ts

@@ -0,0 +1,199 @@
+import { FileEntity } from '../interfaces/file-entity.interface';
+import { IFileProcessor } from '../interfaces/file-processor.interface';
+import { ProcessOptions, ProcessResult } from '../interfaces/processor-options.interface';
+/**
+ * 图片处理器配置
+ */
+export interface ImageProcessorOptions {
+    /** 裁剪选项 */
+    crop?: {
+        /** 宽度 */
+        width: number;
+        /** 高度 */
+        height: number;
+        /** 裁剪位置 */
+        position?: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+        /** 是否保持比例 */
+        fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+    };
+    /** 缩放选项 */
+    resize?: {
+        /** 宽度或百分比 */
+        width?: number;
+        /** 高度或百分比 */
+        height?: number;
+        /** 是否保持宽高比 */
+        keepAspect?: boolean;
+        /** 放大算法 */
+        enlarger?: 'nearest' | 'bilinear' | 'bicubic' | 'no';
+        /** 缩小算法 */
+        reducer?: 'nearest' | 'bilinear' | 'bicubic';
+    };
+    /** 压缩选项 */
+    compress?: {
+        /** 质量 (0-100) */
+        quality?: number;
+        /** 输出格式 */
+        format?: 'jpeg' | 'png' | 'webp' | 'avif' | 'tiff' | 'gif';
+        /** 渐进式JPEG */
+        progressive?: boolean;
+        /** 优化 */
+        optimize?: boolean;
+    };
+    /** 滤镜效果 */
+    filters?: {
+        /** 模糊 */
+        blur?: number;
+        /** 锐化 */
+        sharpen?: boolean | number;
+        /** 亮度调整 (-100 到 100) */
+        brightness?: number;
+        /** 对比度调整 (-100 到 100) */
+        contrast?: number;
+        /** 饱和度调整 (-100 到 100) */
+        saturation?: number;
+        /** 伽马值 */
+        gamma?: number;
+        /** 旋转角度 */
+        rotate?: number;
+        /** 翻转 */
+        flip?: boolean;
+        /** 水平翻转 */
+        flop?: boolean;
+    };
+    /** 水印选项 */
+    watermark?: {
+        /** 水印图片路径 */
+        image?: string;
+        /** 水印文字 */
+        text?: string;
+        /** 位置 */
+        position?: 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+        /** 透明度 (0-1) */
+        opacity?: number;
+        /** 缩放比例 */
+        scale?: number;
+        /** 文字选项 */
+        textOptions?: {
+            /** 字体大小 */
+            size?: number;
+            /** 字体颜色 */
+            color?: string;
+            /** 字体 */
+            font?: string;
+            /** 背景色 */
+            background?: string;
+        };
+    };
+    /** 缩略图生成 */
+    thumbnails?: Array<{
+        /** 名称/标识 */
+        name: string;
+        /** 宽度 */
+        width: number;
+        /** 高度 */
+        height: number;
+        /** 裁剪选项 */
+        fit?: 'cover' | 'contain' | 'fill';
+        /** 质量覆盖 */
+        quality?: number;
+    }>;
+    /** 输出选项 */
+    output?: {
+        /** 是否保留原始文件 */
+        keepOriginal?: boolean;
+        /** 输出目录 */
+        directory?: string;
+        /** 文件名后缀 */
+        suffix?: string;
+        /** 是否覆盖已存在文件 */
+        overwrite?: boolean;
+    };
+}
+/** 图片处理结果 */
+export interface ImageProcessResult {
+    /** 处理状态 */
+    status: 'success' | 'partial' | 'failed';
+    /** 原始图片信息 */
+    original: {
+        width: number;
+        height: number;
+        format: string;
+        size: number;
+        hasAlpha: boolean;
+        channels: number;
+    };
+    /** 处理后的图片信息 */
+    processed?: {
+        width: number;
+        height: number;
+        format: string;
+        size: number;
+        path?: string;
+        url?: string;
+    };
+    /** 缩略图列表 */
+    thumbnails?: Array<{
+        name: string;
+        width: number;
+        height: number;
+        size: number;
+        path?: string;
+        url?: string;
+    }>;
+    /** 压缩率 */
+    compressionRatio?: number;
+    /** 处理耗时（毫秒） */
+    duration: number;
+    /** 错误信息 */
+    error?: string;
+}
+export declare class ImageProcessor implements IFileProcessor {
+    readonly name = "image";
+    readonly supportedTypes: string[];
+    private readonly logger;
+    validate(buffer: Buffer): Promise<boolean>;
+    process(file: FileEntity, options: ProcessOptions & {
+        imageOptions?: ImageProcessorOptions;
+    }): Promise<ProcessResult>;
+    /**
+     * 获取文件缓冲区
+     */
+    private getFileBuffer;
+    /**
+     * 应用滤镜
+     */
+    private applyFilters;
+    /**
+     * 应用裁剪
+     */
+    private applyCrop;
+    /**
+     * 应用缩放
+     */
+    private applyResize;
+    /**
+     * 应用压缩
+     */
+    private applyCompression;
+    /**
+     * 应用水印
+     */
+    private applyWatermark;
+    /**
+     * 创建文字水印SVG
+     */
+    private createTextWatermark;
+    /**
+     * 获取Gravity常量
+     */
+    private getGravity;
+    /**
+     * 生成缩略图
+     */
+    private generateThumbnail;
+}
+/**
+ * 图片处理装饰器
+ */
+export declare function ImageProcess(options: ImageProcessorOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/file-upload/processors/image.processor.js

@@ -0,0 +1,377 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var ImageProcessor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageProcessor = void 0;
+exports.ImageProcess = ImageProcess;
+const common_1 = require("@nestjs/common");
+const dynamic_import_util_1 = require("../utils/dynamic-import.util");
+let ImageProcessor = ImageProcessor_1 = class ImageProcessor {
+    constructor() {
+        this.name = 'image';
+        this.supportedTypes = [
+            'image/jpeg',
+            'image/jpg',
+            'image/png',
+            'image/gif',
+            'image/webp',
+            'image/tiff',
+            'image/avif',
+            'image/svg+xml',
+        ];
+        this.logger = new common_1.Logger(ImageProcessor_1.name);
+    }
+    validate(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const sharp = yield dynamic_import_util_1.DynamicImportUtil.importSharp();
+                const image = sharp(buffer);
+                const metadata = yield image.metadata();
+                return !!metadata.format;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    process(file, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const imageOptions = options.imageOptions || {};
+            const startTime = Date.now();
+            try {
+                // 获取图片缓冲区
+                const buffer = yield this.getFileBuffer(file);
+                // 动态导入 Sharp
+                const sharp = yield dynamic_import_util_1.DynamicImportUtil.importSharp();
+                // 创建Sharp实例
+                let image = sharp(buffer);
+                // 获取原始元数据
+                const originalMetadata = yield image.metadata();
+                // 应用滤镜
+                if (imageOptions.filters) {
+                    image = this.applyFilters(image, imageOptions.filters);
+                }
+                // 应用裁剪
+                if (imageOptions.crop) {
+                    image = this.applyCrop(image, imageOptions.crop);
+                }
+                else if (imageOptions.resize) {
+                    // 应用缩放
+                    image = this.applyResize(image, imageOptions.resize);
+                }
+                // 应用水印
+                if (imageOptions.watermark) {
+                    image = yield this.applyWatermark(image, imageOptions.watermark);
+                }
+                // 设置输出格式和压缩
+                if (imageOptions.compress) {
+                    image = this.applyCompression(image, imageOptions.compress);
+                }
+                // 处理主图片
+                let processedResult;
+                const originalSize = buffer.length;
+                if (!((_a = imageOptions.output) === null || _a === void 0 ? void 0 : _a.keepOriginal) ||
+                    imageOptions.crop ||
+                    imageOptions.resize ||
+                    imageOptions.compress ||
+                    imageOptions.filters) {
+                    const processedBuffer = yield image.toBuffer();
+                    const sharp2 = yield dynamic_import_util_1.DynamicImportUtil.importSharp();
+                    const processedMetadata = yield sharp2(processedBuffer).metadata();
+                    processedResult = {
+                        width: processedMetadata.width,
+                        height: processedMetadata.height,
+                        format: processedMetadata.format,
+                        size: processedBuffer.length,
+                        // 这里应该保存文件并返回路径/URL
+                    };
+                }
+                // 生成缩略图
+                const thumbnails = [];
+                if ((_b = imageOptions.thumbnails) === null || _b === void 0 ? void 0 : _b.length) {
+                    for (const thumb of imageOptions.thumbnails) {
+                        const thumbnail = yield this.generateThumbnail(buffer, thumb, (_c = imageOptions.compress) === null || _c === void 0 ? void 0 : _c.quality);
+                        thumbnails.push(Object.assign(Object.assign({}, thumbnail), { name: thumb.name }));
+                    }
+                }
+                const duration = Date.now() - startTime;
+                const compressionRatio = processedResult
+                    ? (1 - processedResult.size / originalSize) * 100
+                    : 0;
+                const result = {
+                    status: 'success',
+                    original: {
+                        width: originalMetadata.width || 0,
+                        height: originalMetadata.height || 0,
+                        format: originalMetadata.format || 'unknown',
+                        size: originalSize,
+                        hasAlpha: originalMetadata.hasAlpha || false,
+                        channels: originalMetadata.channels || 1,
+                    },
+                    processed: processedResult,
+                    thumbnails: thumbnails.length ? thumbnails : undefined,
+                    compressionRatio: compressionRatio > 0 ? compressionRatio : undefined,
+                    duration,
+                };
+                return {
+                    success: true,
+                    data: result,
+                };
+            }
+            catch (error) {
+                this.logger.error('Image processing failed', error);
+                return {
+                    success: false,
+                    error: error,
+                    data: {
+                        status: 'failed',
+                        original: {
+                            width: 0,
+                            height: 0,
+                            format: 'unknown',
+                            size: 0,
+                            hasAlpha: false,
+                            channels: 1,
+                        },
+                        duration: Date.now() - startTime,
+                        error: error.message,
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 获取文件缓冲区
+     */
+    getFileBuffer(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 注入StorageService来获取文件内容
+            throw new Error('StorageService not injected');
+        });
+    }
+    /**
+     * 应用滤镜
+     */
+    applyFilters(image, filters) {
+        if (filters.blur && filters.blur > 0) {
+            image = image.blur(filters.blur);
+        }
+        if (filters.sharpen) {
+            image =
+                typeof filters.sharpen === 'number'
+                    ? image.sharpen(filters.sharpen)
+                    : image.sharpen();
+        }
+        if (filters.brightness && filters.brightness !== 0) {
+            image = image.modulate({
+                brightness: 1 + filters.brightness / 100,
+            });
+        }
+        if (filters.contrast && filters.contrast !== 0) {
+            image = image.linear(1 + filters.contrast / 100, 0);
+        }
+        if (filters.saturation && filters.saturation !== 0) {
+            image = image.modulate({
+                saturation: 1 + filters.saturation / 100,
+            });
+        }
+        if (filters.gamma && filters.gamma !== 1) {
+            image = image.gamma(filters.gamma);
+        }
+        if (filters.rotate && filters.rotate !== 0) {
+            image = image.rotate(filters.rotate, {
+                background: { r: 255, g: 255, b: 255, alpha: 1 },
+            });
+        }
+        if (filters.flip) {
+            image = image.flip();
+        }
+        if (filters.flop) {
+            image = image.flop();
+        }
+        return image;
+    }
+    /**
+     * 应用裁剪
+     */
+    applyCrop(image, crop) {
+        return image.resize(crop.width, crop.height, {
+            position: crop.position || 'center',
+            fit: crop.fit || 'cover',
+        });
+    }
+    /**
+     * 应用缩放
+     */
+    applyResize(image, resize) {
+        const options = {};
+        if (resize.keepAspect !== false && resize.width && resize.height) {
+            options.fit = 'inside';
+        }
+        return image.resize(resize.width, resize.height, options);
+    }
+    /**
+     * 应用压缩
+     */
+    applyCompression(image, compress) {
+        const format = compress.format || 'jpeg';
+        const options = {
+            quality: compress.quality || 80,
+        };
+        if (format === 'jpeg' && compress.progressive) {
+            options.progressive = true;
+        }
+        if (compress.optimize) {
+            options.force = true;
+        }
+        switch (format) {
+            case 'jpeg':
+                return image.jpeg(options);
+            case 'png':
+                return image.png(options);
+            case 'webp':
+                return image.webp(options);
+            case 'avif':
+                return image.avif(options);
+            case 'tiff':
+                return image.tiff(options);
+            case 'gif':
+                return image.gif(options);
+            default:
+                return image;
+        }
+    }
+    /**
+     * 应用水印
+     */
+    applyWatermark(image, watermark) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (watermark.text) {
+                // 文字水印
+                const svgText = this.createTextWatermark(watermark);
+                const textBuffer = Buffer.from(svgText);
+                return image.composite([
+                    {
+                        input: textBuffer,
+                        gravity: this.getGravity(watermark.position || 'center'),
+                    },
+                ]);
+            }
+            else if (watermark.image) {
+                // 图片水印
+                const sharp = yield dynamic_import_util_1.DynamicImportUtil.importSharp();
+                let watermarkImage = sharp(watermark.image);
+                if (watermark.scale && watermark.scale !== 1) {
+                    const metadata = yield watermarkImage.metadata();
+                    watermarkImage = watermarkImage.resize(Math.round(metadata.width * watermark.scale), Math.round(metadata.height * watermark.scale));
+                }
+                const watermarkBuffer = yield watermarkImage.toBuffer();
+                return image.composite([
+                    {
+                        input: watermarkBuffer,
+                        gravity: this.getGravity(watermark.position || 'center'),
+                        blend: 'over',
+                    },
+                ]);
+            }
+            return image;
+        });
+    }
+    /**
+     * 创建文字水印SVG
+     */
+    createTextWatermark(watermark) {
+        const text = watermark.text;
+        const options = watermark.textOptions || {};
+        const fontSize = options.size || 40;
+        const color = options.color || 'rgba(255, 255, 255, 0.5)';
+        const font = options.font || 'Arial';
+        return `
+      <svg width="300" height="100">
+        <rect width="100%" height="100%" fill="${options.background || 'transparent'}" />
+        <text
+          x="50%"
+          y="50%"
+          text-anchor="middle"
+          dominant-baseline="middle"
+          font-family="${font}"
+          font-size="${fontSize}"
+          fill="${color}">
+          ${text}
+        </text>
+      </svg>
+    `;
+    }
+    /**
+     * 获取Gravity常量
+     */
+    getGravity(position) {
+        const gravityMap = {};
+        return gravityMap[position] || 'center';
+    }
+    /**
+     * 生成缩略图
+     */
+    generateThumbnail(buffer, thumb, quality) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sharp = yield dynamic_import_util_1.DynamicImportUtil.importSharp();
+            let image = sharp(buffer);
+            image = image.resize(thumb.width, thumb.height, {
+                fit: thumb.fit || 'cover',
+            });
+            if (quality || thumb.quality) {
+                image = image.jpeg({
+                    quality: quality || thumb.quality || 80,
+                    progressive: true,
+                });
+            }
+            const thumbnailBuffer = yield image.toBuffer();
+            const metadata = yield image.metadata();
+            return {
+                width: metadata.width || thumb.width,
+                height: metadata.height || thumb.height,
+                size: thumbnailBuffer.length,
+                // 这里应该保存文件并返回路径/URL
+            };
+        });
+    }
+};
+exports.ImageProcessor = ImageProcessor;
+exports.ImageProcessor = ImageProcessor = ImageProcessor_1 = __decorate([
+    (0, common_1.Injectable)()
+], ImageProcessor);
+/**
+ * 图片处理装饰器
+ */
+function ImageProcess(options) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata('image:options', options, descriptor.value);
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const result = yield originalMethod.apply(this, args);
+                // 如果方法返回了文件，自动处理
+                if (result && result.originalName && result.buffer) {
+                    const processor = new ImageProcessor();
+                    return yield processor.process(result, { imageOptions: options });
+                }
+                return result;
+            });
+        };
+    };
+}

package/file-upload/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './local-storage.provider';
+export * from './s3-storage.provider';

package/file-upload/providers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./local-storage.provider"), exports);
+__exportStar(require("./s3-storage.provider"), exports);

package/file-upload/providers/local-storage.provider.d.ts

@@ -0,0 +1,98 @@
+import { BatchDeleteResult, CopyResult, HealthStatus, IStorageProvider, ListResult, LocalStorageOptions, MoveResult, PreSignedUploadInfo, UploadResult } from '../interfaces/storage-provider.interface';
+import { FileBuffer } from '../interfaces/file-buffer.interface';
+import { UploadOptions } from '../interfaces/upload-options.interface';
+import { FileMetadata } from '../interfaces/file-metadata.interface';
+/**
+ * 本地文件存储提供者
+ */
+export declare class LocalStorageProvider implements IStorageProvider {
+    private readonly options;
+    name: string;
+    private readonly logger;
+    private initialized;
+    constructor(options: LocalStorageOptions);
+    /**
+     * 初始化存储配置
+     */
+    initialize(): Promise<void>;
+    /**
+     * 上传文件
+     */
+    upload(file: FileBuffer, options: UploadOptions): Promise<UploadResult>;
+    /**
+     * 下载文件
+     */
+    download(filePath: string): Promise<FileBuffer>;
+    /**
+     * 删除文件
+     */
+    delete(filePath: string): Promise<void>;
+    /**
+     * 批量删除
+     */
+    deleteBatch(paths: string[]): Promise<BatchDeleteResult>;
+    /**
+     * 检查文件是否存在
+     */
+    exists(filePath: string): Promise<boolean>;
+    /**
+     * 获取文件元数据
+     */
+    getMetadata(filePath: string): Promise<FileMetadata>;
+    /**
+     * 获取预签名URL（本地存储不支持，返回直接URL）
+     */
+    getSignedUrl(filePath: string, expiresIn?: number): Promise<string>;
+    /**
+     * 获取预签名上传URL（本地存储不支持）
+     */
+    getSignedUploadUrl(filePath: string, expiresIn?: number, contentType?: string): Promise<PreSignedUploadInfo>;
+    /**
+     * 复制文件
+     */
+    copy(sourcePath: string, destinationPath: string): Promise<CopyResult>;
+    /**
+     * 移动文件
+     */
+    move(sourcePath: string, destinationPath: string): Promise<MoveResult>;
+    /**
+     * 列出文件
+     */
+    list(prefix?: string, limit?: number): Promise<ListResult>;
+    /**
+     * 健康检查
+     */
+    healthCheck(): Promise<HealthStatus>;
+    /**
+     * 生成文件路径
+     */
+    private generateFilePath;
+    /**
+     * 获取文件URL
+     */
+    private getFileUrl;
+    /**
+     * 计算文件哈希
+     */
+    private calculateFileHash;
+    /**
+     * 递归读取目录
+     */
+    private readDirRecursive;
+    /**
+     * 验证路径安全性，防止路径遍历攻击
+     */
+    private validatePath;
+    /**
+     * 验证文件是否在上传目录内
+     */
+    private ensurePathWithinUpload;
+    /**
+     * 根据扩展名获取 MIME 类型
+     */
+    private getMimeTypeFromExtension;
+    /**
+     * 确保已初始化
+     */
+    private ensureInitialized;
+}