ai-yuca 1.0.0

package/dist/src/types/upload.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 上传功能相关类型定义
+ */
+import { Storage } from '@google-cloud/storage';
+/**
+ * 存储客户端选项接口
+ */
+export interface StorageClientOptions {
+    keyFilename?: string;
+    projectId?: string;
+    credentials?: {
+        client_email?: string;
+        private_key?: string;
+    };
+}
+/**
+ * 文件上传选项接口
+ */
+export interface UploadFileOptions {
+    bucketName: string;
+    filePath: string;
+    destination?: string;
+    storageClient: Storage;
+    /**
+     * 是否启用GZIP压缩（对js、css、json、html、woff文件类型）
+     * @default true
+     */
+    enableCompression?: boolean;
+}
+/**
+ * 批量上传选项接口
+ */
+export interface UploadFilesOptions {
+    bucketName: string;
+    sourcePath: string | string[];
+    destination?: string;
+    storageClient: Storage;
+    recursive?: boolean;
+    /**
+     * 是否启用GZIP压缩（对js、css、json、html、woff文件类型）
+     * @default true
+     */
+    enableCompression?: boolean;
+}
+/**
+ * 上传成功结果接口
+ */
+export interface UploadSuccessResult {
+    success: true;
+    file: string;
+    size: string | number;
+    contentType: string;
+    timeCreated: string;
+    url: string;
+}
+/**
+ * 上传失败结果接口
+ */
+export interface UploadFailedResult {
+    success: false;
+    file: string;
+    error: string;
+}
+/**
+ * 上传结果类型
+ */
+export type UploadResult = UploadSuccessResult | UploadFailedResult;
+/**
+ * 批量上传结果接口
+ */
+export interface UploadFilesResult {
+    success: UploadSuccessResult[];
+    failed: UploadFailedResult[];
+}
+/**
+ * CLI上传命令选项接口
+ */
+export interface UploadCommandOptions {
+    source: string[];
+    bucket: string;
+    destination?: string;
+    keyFile?: string;
+    recursive: boolean;
+    /**
+     * 是否启用GZIP压缩（对js、css、json、html、woff文件类型）
+     * @default true
+     */
+    compression?: boolean;
+}

package/dist/src/types/upload.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/upload.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GCP上传功能模块
+ */
+import { Storage } from '@google-cloud/storage';
+import { StorageClientOptions, UploadFileOptions, UploadFilesOptions, UploadResult, UploadFilesResult } from './types/upload';
+/**
+ * 创建GCP存储客户端
+ * @param options - 配置选项
+ * @returns GCP存储客户端实例
+ */
+declare function createStorageClient(options?: Partial<StorageClientOptions>): Storage;
+/**
+ * 上传单个文件到GCP存储桶
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+declare function uploadFile(options: UploadFileOptions): Promise<UploadResult>;
+/**
+ * 批量上传文件到GCP存储桶
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+declare function uploadFiles(options: UploadFilesOptions): Promise<UploadFilesResult>;
+export { createStorageClient, uploadFile, uploadFiles };

package/dist/src/upload.js

@@ -0,0 +1,252 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorageClient = createStorageClient;
+exports.uploadFile = uploadFile;
+exports.uploadFiles = uploadFiles;
+/**
+ * GCP上传功能模块
+ */
+const storage_1 = require("@google-cloud/storage");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util = __importStar(require("util"));
+const compression_1 = require("./utils/compression");
+const readdir = util.promisify(fs.readdir);
+const stat = util.promisify(fs.stat);
+/**
+ * 创建GCP存储客户端
+ * @param options - 配置选项
+ * @returns GCP存储客户端实例
+ */
+function createStorageClient(options = {}) {
+    const { keyFilename, projectId, credentials } = options;
+    // 如果提供了keyFilename，使用密钥文件认证
+    if (keyFilename) {
+        return new storage_1.Storage({
+            keyFilename
+        });
+    }
+    // 如果提供了credentials，使用凭证对象认证
+    if (credentials) {
+        return new storage_1.Storage({
+            projectId,
+            credentials
+        });
+    }
+    // 使用应用默认凭证（ADC）进行免密认证
+    // 这将使用环境变量GOOGLE_APPLICATION_CREDENTIALS或默认服务账号
+    return new storage_1.Storage();
+}
+/**
+ * 上传单个文件到GCP存储桶
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+async function uploadFile(options) {
+    const { bucketName, filePath, destination, storageClient, enableCompression = true } = options;
+    if (!bucketName || !filePath || !storageClient) {
+        throw new Error('缺少必要的上传参数');
+    }
+    try {
+        // 检查文件是否存在
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`文件不存在: ${filePath}`);
+        }
+        // 获取存储桶
+        const bucket = storageClient.bucket(bucketName);
+        // 确定目标路径
+        const destPath = destination || path.basename(filePath);
+        // 检查是否需要压缩
+        let fileToUpload = filePath;
+        let contentEncoding;
+        let contentType;
+        if (enableCompression && (0, compression_1.shouldCompressFile)(filePath)) {
+            // 压缩文件
+            fileToUpload = await (0, compression_1.compressFile)(filePath);
+            contentEncoding = 'gzip';
+            // 根据文件扩展名设置正确的Content-Type
+            const ext = path.extname(filePath).toLowerCase();
+            switch (ext) {
+                case '.js':
+                    contentType = 'application/javascript';
+                    break;
+                case '.css':
+                    contentType = 'text/css';
+                    break;
+                case '.json':
+                    contentType = 'application/json';
+                    break;
+                case '.html':
+                    contentType = 'text/html';
+                    break;
+                case '.woff':
+                    contentType = 'font/woff';
+                    break;
+                default:
+                    contentType = 'application/octet-stream';
+            }
+        }
+        // 上传文件
+        const [file] = await bucket.upload(fileToUpload, {
+            destination: destPath,
+            // 设置元数据
+            metadata: {
+                // 为.json文件设置缓存时间为0，其他文件保持一年缓存
+                cacheControl: path.extname(filePath).toLowerCase() === '.json' ? 'public, max-age=0' : 'public, max-age=31536000',
+                contentEncoding,
+                contentType
+            },
+        });
+        // 如果上传了压缩文件，删除临时文件
+        if (fileToUpload !== filePath && fs.existsSync(fileToUpload)) {
+            fs.unlinkSync(fileToUpload);
+        }
+        // 获取文件公共URL
+        const [metadata] = await file.getMetadata();
+        return {
+            success: true,
+            file: metadata.name || path.basename(filePath),
+            size: metadata.size || 0,
+            contentType: metadata.contentType || 'application/octet-stream',
+            timeCreated: metadata.timeCreated || new Date().toISOString(),
+            url: `https://storage.googleapis.com/${bucketName}/${metadata.name || path.basename(filePath)}`
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            file: filePath,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * 批量上传文件到GCP存储桶
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+async function uploadFiles(options) {
+    const { bucketName, sourcePath, destination, storageClient, recursive = false, enableCompression = true } = options;
+    if (!bucketName || !sourcePath || !storageClient) {
+        throw new Error('缺少必要的上传参数');
+    }
+    const results = {
+        success: [],
+        failed: []
+    };
+    try {
+        // 如果sourcePath是数组，批量上传多个文件
+        if (Array.isArray(sourcePath)) {
+            for (const filePath of sourcePath) {
+                const result = await uploadFile({
+                    bucketName,
+                    filePath,
+                    destination: destination ? `${destination}/${path.basename(filePath)}` : undefined,
+                    storageClient,
+                    enableCompression
+                });
+                if (result.success) {
+                    results.success.push(result);
+                }
+                else {
+                    results.failed.push(result);
+                }
+            }
+            return results;
+        }
+        // 检查sourcePath是文件还是目录
+        const stats = await stat(sourcePath);
+        if (stats.isFile()) {
+            // 上传单个文件
+            const result = await uploadFile({
+                bucketName,
+                filePath: sourcePath,
+                destination,
+                storageClient,
+                enableCompression
+            });
+            if (result.success) {
+                results.success.push(result);
+            }
+            else {
+                results.failed.push(result);
+            }
+        }
+        else if (stats.isDirectory()) {
+            // 上传目录中的文件
+            const files = await readdir(sourcePath);
+            for (const file of files) {
+                const filePath = path.join(sourcePath, file);
+                const fileStats = await stat(filePath);
+                if (fileStats.isFile()) {
+                    // 上传文件
+                    const destPath = destination ? `${destination}/${file}` : file;
+                    const result = await uploadFile({
+                        bucketName,
+                        filePath,
+                        destination: destPath,
+                        storageClient,
+                        enableCompression
+                    });
+                    if (result.success) {
+                        results.success.push(result);
+                    }
+                    else {
+                        results.failed.push(result);
+                    }
+                }
+                else if (recursive && fileStats.isDirectory()) {
+                    // 递归上传子目录
+                    const subDestination = destination ? `${destination}/${file}` : file;
+                    const subResults = await uploadFiles({
+                        bucketName,
+                        sourcePath: filePath,
+                        destination: subDestination,
+                        storageClient,
+                        recursive,
+                        enableCompression
+                    });
+                    results.success = results.success.concat(subResults.success);
+                    results.failed = results.failed.concat(subResults.failed);
+                }
+            }
+        }
+        return results;
+    }
+    catch (error) {
+        throw new Error(`上传文件失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/src/uploadWithConfig.d.ts

@@ -0,0 +1,34 @@
+import { StorageClientOptions, UploadFilesResult } from './types/upload';
+/**
+ * 基于配置文件的上传选项
+ */
+export interface UploadWithConfigOptions {
+    /** 存储客户端配置选项 */
+    storageClientOptions?: Partial<StorageClientOptions>;
+    /** 配置文件路径，默认为项目根目录下的vs.config.json */
+    configPath?: string;
+    /** 是否递归上传子目录，默认为true */
+    recursive?: boolean;
+    /** 是否启用压缩，默认为true */
+    enableCompression?: boolean;
+    /** 自定义源路径，如果提供则覆盖配置文件中的uploadPath */
+    customSourcePath?: string;
+    /** 自定义目标路径，如果提供则覆盖配置文件中的目标路径 */
+    customDestination?: string;
+}
+/**
+ * 基于配置文件批量上传文件
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+export declare function uploadFilesWithConfig(options?: UploadWithConfigOptions): Promise<UploadFilesResult>;
+/**
+ * 获取配置信息（用于调试或显示）
+ * @param configPath - 配置文件路径
+ * @returns 配置信息摘要
+ */
+export declare function getConfigSummary(configPath?: string): {
+    bucketName: string;
+    sourcePath: string;
+    destination: string;
+};

package/dist/src/uploadWithConfig.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFilesWithConfig = uploadFilesWithConfig;
+exports.getConfigSummary = getConfigSummary;
+/**
+ * 基于配置文件的GCP上传功能模块
+ */
+const storage_1 = require("@google-cloud/storage");
+const upload_1 = require("./upload");
+const config_1 = require("./config");
+/**
+ * 创建存储客户端
+ * @param options - 客户端配置选项
+ * @returns GCP存储客户端实例
+ */
+function createStorageClientFromConfig(options = {}) {
+    const { keyFilename, projectId, credentials } = options;
+    // 如果提供了keyFilename，使用密钥文件认证
+    if (keyFilename) {
+        return new storage_1.Storage({
+            keyFilename
+        });
+    }
+    // 如果提供了credentials，使用凭证对象认证
+    if (credentials) {
+        return new storage_1.Storage({
+            projectId,
+            credentials
+        });
+    }
+    // 使用应用默认凭证（ADC）进行免密认证
+    return new storage_1.Storage();
+}
+/**
+ * 基于配置文件批量上传文件
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+async function uploadFilesWithConfig(options = {}) {
+    const { storageClientOptions = {}, configPath, recursive = true, enableCompression = true, customSourcePath, customDestination } = options;
+    try {
+        // 加载配置文件
+        const config = (0, config_1.loadConfig)(configPath);
+        // 创建存储客户端
+        const storageClient = createStorageClientFromConfig(storageClientOptions);
+        // 获取配置信息
+        const bucketName = (0, config_1.getBucketName)(config);
+        const sourcePath = customSourcePath || (0, config_1.getUploadSourcePath)(config);
+        const destination = customDestination || (0, config_1.getUploadDestination)(config);
+        console.log(`开始上传文件...`);
+        console.log(`源路径: ${sourcePath}`);
+        console.log(`目标桶: ${bucketName}`);
+        console.log(`目标路径: ${destination}`);
+        // 执行批量上传
+        const result = await (0, upload_1.uploadFiles)({
+            bucketName,
+            sourcePath,
+            destination,
+            storageClient,
+            recursive,
+            enableCompression
+        });
+        console.log(`上传完成! 成功: ${result.success.length}, 失败: ${result.failed.length}`);
+        return result;
+    }
+    catch (error) {
+        throw new Error(`基于配置文件的上传失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * 获取配置信息（用于调试或显示）
+ * @param configPath - 配置文件路径
+ * @returns 配置信息摘要
+ */
+function getConfigSummary(configPath) {
+    const config = (0, config_1.loadConfig)(configPath);
+    return {
+        bucketName: (0, config_1.getBucketName)(config),
+        sourcePath: (0, config_1.getUploadSourcePath)(config),
+        destination: (0, config_1.getUploadDestination)(config)
+    };
+}

package/dist/src/utils/compression.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 需要进行GZIP压缩的文件扩展名
+ */
+export declare const COMPRESSIBLE_EXTENSIONS: string[];
+/**
+ * 检查文件是否需要压缩
+ * @param filePath - 文件路径
+ * @returns 是否需要压缩
+ */
+export declare function shouldCompressFile(filePath: string): boolean;
+/**
+ * 使用GZIP压缩文件
+ * @param inputPath - 输入文件路径
+ * @returns 压缩后的临时文件路径
+ */
+export declare function compressFile(inputPath: string): Promise<string>;

package/dist/src/utils/compression.js

@@ -0,0 +1,85 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPRESSIBLE_EXTENSIONS = void 0;
+exports.shouldCompressFile = shouldCompressFile;
+exports.compressFile = compressFile;
+const fs_1 = require("fs");
+const zlib = __importStar(require("zlib"));
+const path = __importStar(require("path"));
+const util = __importStar(require("util"));
+const os = __importStar(require("os"));
+const stream_1 = require("stream");
+const pipeline = util.promisify(stream_1.pipeline);
+/**
+ * 需要进行GZIP压缩的文件扩展名
+ */
+exports.COMPRESSIBLE_EXTENSIONS = [
+    '.js',
+    '.css',
+    '.json',
+    '.html',
+    '.woff'
+];
+/**
+ * 检查文件是否需要压缩
+ * @param filePath - 文件路径
+ * @returns 是否需要压缩
+ */
+function shouldCompressFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return exports.COMPRESSIBLE_EXTENSIONS.includes(ext);
+}
+/**
+ * 使用GZIP压缩文件
+ * @param inputPath - 输入文件路径
+ * @returns 压缩后的临时文件路径
+ */
+async function compressFile(inputPath) {
+    // 创建临时文件路径
+    const tempDir = os.tmpdir();
+    const fileName = path.basename(inputPath);
+    const outputPath = path.join(tempDir, `${fileName}.gz`);
+    // 创建读取流、GZIP压缩流和写入流
+    const gzip = zlib.createGzip();
+    try {
+        // 使用pipeline进行流处理
+        await pipeline((0, fs_1.createReadStream)(inputPath), gzip, (0, fs_1.createWriteStream)(outputPath));
+        return outputPath;
+    }
+    catch (error) {
+        throw new Error(`压缩文件失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/test/compression.test.d.ts

@@ -0,0 +1 @@
+export {};