@nest-omni/core 4.1.3-12 → 4.1.3-14

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/services/file.service.d.ts

@@ -39,6 +39,8 @@ export declare class FileService {
     private readonly localStorageProvider?;
     private readonly s3StorageProvider?;
     private readonly logger;
+    private readonly ALLOWED_ORDER_FIELDS;
+    private readonly ALLOWED_ORDER_DIRECTIONS;
     constructor(fileRepository: Repository<FileEntity>, metadataRepository: Repository<FileMetadataEntity>, storageProvider?: IStorageProvider, localStorageProvider?: IStorageProvider, s3StorageProvider?: IStorageProvider);
     /**
      * 创建文件记录
@@ -86,6 +88,7 @@ export declare class FileService {
     getStorageStats(userId?: string): Promise<StorageStats>;
     /**
      * 更新处理状态
+     * 处理状态信息保存到 file_metadata 表
      */
     updateProcessingStatus(fileId: string, processor: string, status: 'pending' | 'completed' | 'failed', result?: any, error?: string): Promise<void>;
     /**

package/file-upload/services/file.service.js

@@ -41,6 +41,22 @@ let FileService = FileService_1 = class FileService {
         this.localStorageProvider = localStorageProvider;
         this.s3StorageProvider = s3StorageProvider;
         this.logger = new common_1.Logger(FileService_1.name);
+        // 允许的排序字段白名单（防止 SQL 注入）
+        this.ALLOWED_ORDER_FIELDS = [
+            'createdAt',
+            'updatedAt',
+            'size',
+            'originalName',
+            'filename',
+            'mimeType',
+            'status',
+            'fileType',
+            'extension',
+            'uploadId',
+            'userId',
+        ];
+        // 允许的排序方向
+        this.ALLOWED_ORDER_DIRECTIONS = ['ASC', 'DESC'];
     }
     /**
      * 创建文件记录
@@ -86,6 +102,7 @@ let FileService = FileService_1 = class FileService {
      */
     findFiles(query, pagination) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const queryBuilder = this.fileRepository.createQueryBuilder('file');
             // 应用筛选条件
             if (query.userId) {
@@ -129,15 +146,23 @@ let FileService = FileService_1 = class FileService {
             if (query.search) {
                 // 转义 LIKE 操作符中的特殊字符
                 const escapedSearch = this.escapeLikeString(query.search);
-                queryBuilder.andWhere('(file.originalName ILIKE :search OR file.filename ILIKE :search)', {
+                queryBuilder.andWhere('(file.originalName LIKE :search OR file.filename LIKE :search)', {
                     search: `%${escapedSearch}%`,
                 });
             }
             // 排除软删除的记录
             queryBuilder.andWhere('file.deletedAt IS NULL');
-            // 应用排序
+            // 应用排序（带安全验证）
             const orderBy = query.orderBy || 'createdAt';
-            const orderDirection = query.orderDirection || 'DESC';
+            const orderDirection = (((_a = query.orderDirection) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'DESC');
+            // 验证排序字段
+            if (!this.ALLOWED_ORDER_FIELDS.includes(orderBy)) {
+                throw new common_1.BadRequestException(`Invalid order field: ${orderBy}. Allowed fields: ${this.ALLOWED_ORDER_FIELDS.join(', ')}`);
+            }
+            // 验证排序方向
+            if (!this.ALLOWED_ORDER_DIRECTIONS.includes(orderDirection)) {
+                throw new common_1.BadRequestException(`Invalid order direction: ${orderDirection}. Allowed: ASC, DESC`);
+            }
             queryBuilder.orderBy(`file.${orderBy}`, orderDirection);
             // 应用分页
             const offset = (pagination.page - 1) * pagination.limit;
@@ -292,6 +317,7 @@ let FileService = FileService_1 = class FileService {
     }
     /**
      * 更新处理状态
+     * 处理状态信息保存到 file_metadata 表
      */
     updateProcessingStatus(fileId, processor, status, result, error) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -300,16 +326,19 @@ let FileService = FileService_1 = class FileService {
                 this.logger.warn(`File not found for processing update: ${fileId}`);
                 return;
             }
-            if (status === 'pending') {
-                file.addProcessingStep(processor);
-            }
-            else {
-                file.updateProcessingStep(processor, status, result, error);
-            }
+            // 将处理状态保存到 metadata
+            const processingKey = `processing_${processor}`;
+            yield this.addMetadata(fileId, processingKey, {
+                processor,
+                status,
+                result: result || null,
+                error: error || null,
+                timestamp: new Date().toISOString(),
+            });
             if (status === 'failed') {
                 file.markAsFailed(`Processor ${processor} failed: ${error}`);
+                yield this.fileRepository.save(file);
             }
-            yield this.fileRepository.save(file);
         });
     }
     /**