ai-yuca 1.0.0

package/src/types/download.ts

@@ -0,0 +1,67 @@
+/**
+ * 下载功能相关类型定义
+ */
+import { Storage } from '@google-cloud/storage';
+
+/**
+ * 下载选项接口
+ */
+export interface DownloadFileOptions {
+  bucketName: string;
+  sourcePath: string;
+  destinationPath: string;
+  storageClient: Storage;
+}
+
+/**
+ * 批量下载选项接口
+ */
+export interface DownloadFilesOptions {
+  bucketName: string;
+  sourcePath: string;
+  destinationPath: string;
+  storageClient: Storage;
+  recursive?: boolean;
+}
+
+/**
+ * 下载成功结果接口
+ */
+export interface DownloadSuccessResult {
+  success: true;
+  file: string;
+  localPath: string;
+}
+
+/**
+ * 下载失败结果接口
+ */
+export interface DownloadFailedResult {
+  success: false;
+  file: string;
+  error: string;
+}
+
+/**
+ * 下载结果类型
+ */
+export type DownloadResult = DownloadSuccessResult | DownloadFailedResult;
+
+/**
+ * 批量下载结果接口
+ */
+export interface DownloadFilesResult {
+  success: DownloadSuccessResult[];
+  failed: DownloadFailedResult[];
+}
+
+/**
+ * CLI下载命令选项接口
+ */
+export interface DownloadCommandOptions {
+  source: string;
+  bucket: string;
+  destination: string;
+  keyFile?: string;
+  recursive: boolean;
+}

package/src/types/index.ts

@@ -0,0 +1,16 @@
+/**
+ * 类型定义索引文件
+ */
+
+// 导出所有上传相关类型
+export * from './upload';
+
+// 导出所有下载相关类型
+export * from './download';
+
+// 导出所有配置相关类型
+export * from '../config';
+export * from '../uploadWithConfig';
+
+// 导出所有分析相关类型
+export * from './analyze';

package/src/types/upload.ts

@@ -0,0 +1,97 @@
+/**
+ * 上传功能相关类型定义
+ */
+import { Storage, Bucket } 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/src/upload.js

@@ -0,0 +1,197 @@
+/**
+ * GCP上传功能模块
+ */
+const {Storage} = require('@google-cloud/storage');
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const readdir = util.promisify(fs.readdir);
+const stat = util.promisify(fs.stat);
+
+/**
+ * 创建GCP存储客户端
+ * @param {Object} options - 配置选项
+ * @param {string} options.keyFilename - 服务账号密钥文件路径
+ * @returns {Storage} GCP存储客户端实例
+ */
+function createStorageClient(options = {}) {
+  const { keyFilename } = options;
+  
+  if (!keyFilename) {
+    throw new Error('必须提供GCP服务账号密钥文件路径');
+  }
+  
+  return new Storage({
+    keyFilename
+  });
+}
+
+/**
+ * 上传单个文件到GCP存储桶
+ * @param {Object} options - 上传选项
+ * @param {string} options.bucketName - GCP存储桶名称
+ * @param {string} options.filePath - 要上传的本地文件路径
+ * @param {string} options.destination - 目标路径（存储桶中的路径）
+ * @param {Storage} options.storageClient - GCP存储客户端实例
+ * @returns {Promise<Object>} 上传结果
+ */
+async function uploadFile(options) {
+  const { bucketName, filePath, destination, storageClient } = 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);
+    
+    // 上传文件
+    const [file] = await bucket.upload(filePath, {
+      destination: destPath,
+      // 可选：设置元数据
+      metadata: {
+        cacheControl: 'public, max-age=31536000',
+      },
+    });
+    
+    // 获取文件公共URL
+    const [metadata] = await file.getMetadata();
+    
+    return {
+      success: true,
+      file: metadata.name,
+      size: metadata.size,
+      contentType: metadata.contentType,
+      timeCreated: metadata.timeCreated,
+      url: `https://storage.googleapis.com/${bucketName}/${metadata.name}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      file: filePath,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * 批量上传文件到GCP存储桶
+ * @param {Object} options - 上传选项
+ * @param {string} options.bucketName - GCP存储桶名称
+ * @param {string|string[]} options.sourcePath - 要上传的本地文件路径或目录
+ * @param {string} options.destination - 目标路径（存储桶中的路径）
+ * @param {Storage} options.storageClient - GCP存储客户端实例
+ * @param {boolean} options.recursive - 是否递归上传目录中的文件
+ * @returns {Promise<Object>} 上传结果
+ */
+async function uploadFiles(options) {
+  const { bucketName, sourcePath, destination, storageClient, recursive = false } = 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 ? path.join(destination, path.basename(filePath)) : undefined,
+          storageClient
+        });
+        
+        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
+      });
+      
+      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 ? path.join(destination, file) : file;
+          
+          const result = await uploadFile({
+            bucketName,
+            filePath,
+            destination: destPath,
+            storageClient
+          });
+          
+          if (result.success) {
+            results.success.push(result);
+          } else {
+            results.failed.push(result);
+          }
+        } else if (recursive && fileStats.isDirectory()) {
+          // 递归上传子目录
+          const subDestination = destination ? path.join(destination, file) : file;
+          
+          const subResults = await uploadFiles({
+            bucketName,
+            sourcePath: filePath,
+            destination: subDestination,
+            storageClient,
+            recursive
+          });
+          
+          results.success = results.success.concat(subResults.success);
+          results.failed = results.failed.concat(subResults.failed);
+        }
+      }
+    }
+    
+    return results;
+  } catch (error) {
+    throw new Error(`上传文件失败: ${error.message}`);
+  }
+}
+
+module.exports = {
+  createStorageClient,
+  uploadFile,
+  uploadFiles
+};

package/src/upload.ts

@@ -0,0 +1,254 @@
+/**
+ * GCP上传功能模块
+ */
+import { Storage, Bucket, File } from '@google-cloud/storage';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as util from 'util';
+import {
+  StorageClientOptions,
+  UploadFileOptions,
+  UploadFilesOptions,
+  UploadSuccessResult,
+  UploadFailedResult,
+  UploadResult,
+  UploadFilesResult
+} from './types/upload';
+import { shouldCompressFile, compressFile } from './utils/compression';
+
+const readdir = util.promisify(fs.readdir);
+const stat = util.promisify(fs.stat);
+
+/**
+ * 创建GCP存储客户端
+ * @param options - 配置选项
+ * @returns GCP存储客户端实例
+ */
+function createStorageClient(options: Partial<StorageClientOptions> = {}): Storage {
+  const { keyFilename, projectId, credentials } = options;
+  
+  // 如果提供了keyFilename，使用密钥文件认证
+  if (keyFilename) {
+    return new Storage({
+      keyFilename
+    });
+  }
+  
+  // 如果提供了credentials，使用凭证对象认证
+  if (credentials) {
+    return new Storage({
+      projectId,
+      credentials
+    });
+  }
+  
+  // 使用应用默认凭证（ADC）进行免密认证
+  // 这将使用环境变量GOOGLE_APPLICATION_CREDENTIALS或默认服务账号
+  return new Storage();
+}
+
+/**
+ * 上传单个文件到GCP存储桶
+ * @param options - 上传选项
+ * @returns 上传结果
+ */
+async function uploadFile(options: UploadFileOptions): Promise<UploadResult> {
+  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: Bucket = storageClient.bucket(bucketName);
+    
+    // 确定目标路径
+    const destPath = destination || path.basename(filePath);
+    
+    // 检查是否需要压缩
+    let fileToUpload = filePath;
+    let contentEncoding: string | undefined;
+    let contentType: string | undefined;
+    
+    if (enableCompression && shouldCompressFile(filePath)) {
+      // 压缩文件
+      fileToUpload = await 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: UploadFilesOptions): Promise<UploadFilesResult> {
+  const { bucketName, sourcePath, destination, storageClient, recursive = false, enableCompression = true } = options;
+  
+  if (!bucketName || !sourcePath || !storageClient) {
+    throw new Error('缺少必要的上传参数');
+  }
+  
+  const results: UploadFilesResult = {
+    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)}`);
+  }
+}
+
+export {
+  createStorageClient,
+  uploadFile,
+  uploadFiles
+};