koishi-plugin-media-luna 0.0.43 → 0.0.45

package/lib/plugins/cache/service.js

@@ -1,5 +1,6 @@
 "use strict";
-// 缓存服务 - 本地文件缓存（使用数据库存储元数据）
+// 统一存储服务 - 支持本地/S3/WebDAV 多后端
+// 根据配置的 backend 自动选择存储方式
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -39,10 +40,12 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
 const core_1 = require("../../core");
+const s3_1 = require("./utils/s3");
+const webdav_1 = require("./utils/webdav");
+const mime_1 = require("./utils/mime");
 /**
- * 本地缓存服务
- * 提供文件缓存和 HTTP 访问支持
- * 使用数据库存储元数据，支持 sourceHash 和 contentHash 两级去重
+ * 统一存储服务
+ * 根据配置的 backend 自动选择存储方式（local/s3/webdav）
  */
 class CacheService {
     logger;
@@ -51,7 +54,7 @@ class CacheService {
     publicPath;
     publicBaseUrl;
     config;
-    /** 基础URL（从 selfUrl 获取），用于生成访问链接 */
+    /** 基础URL（从 selfUrl 获取），用于生成本地访问链接 */
     baseUrl = '';
     /** 内存缓存（加速查询） */
     memoryCache = new Map();
@@ -61,7 +64,7 @@ class CacheService {
         this.ctx = ctx;
         this.logger = (0, core_1.createPluginLogger)(ctx.logger('media-luna'), 'cache');
         this.config = config;
-        // 使用配置的目录路径，或默认值
+        // 本地缓存目录（即使使用 S3/WebDAV，也可能需要临时存储）
         this.cacheRoot = path.join(ctx.baseDir, config.cacheDir || 'data/media-luna/cache');
         this.publicPath = config.publicPath || '/media-luna/cache';
         this.publicBaseUrl = config.publicBaseUrl?.replace(/\/$/, '') || null;
@@ -70,7 +73,7 @@ class CacheService {
         this.initialize().catch(e => {
             this.logger.error('Failed to initialize cache service: %s', e);
         });
-        this.logger.info('Cache service initialized at: %s', this.cacheRoot);
+        this.logger.info('Cache service initialized, backend: %s', config.backend || 'local');
     }
     /** 异步初始化 */
     async initialize() {
@@ -79,8 +82,10 @@ class CacheService {
         try {
             // 从数据库加载到内存缓存
             await this.loadFromDatabase();
-            // 清理过期缓存
-            await this.cleanupExpired();
+            // 清理过期缓存（仅本地模式）
+            if (this.config.backend === 'local' || !this.config.backend) {
+                await this.cleanupExpired();
+            }
             this.initialized = true;
         }
         catch (e) {
@@ -92,7 +97,7 @@ class CacheService {
         try {
             const records = await this.ctx.database.get('medialuna_asset_cache', {});
             for (const record of records) {
-                const localPath = path.join(this.cacheRoot, `${record.contentHash}${this.getExtensionFromMime(record.mimeType)}`);
+                const localPath = path.join(this.cacheRoot, record.cachedKey);
                 this.memoryCache.set(record.contentHash, {
                     id: record.contentHash,
                     filename: path.basename(record.cachedKey),
@@ -101,7 +106,8 @@ class CacheService {
                     createdAt: record.createdAt,
                     accessedAt: record.lastAccessedAt,
                     localPath,
-                    url: record.cachedUrl
+                    url: record.cachedUrl,
+                    backend: record.backend
                 });
             }
             this.logger.debug('Loaded %d cache entries from database', records.length);
@@ -113,6 +119,7 @@ class CacheService {
     /** 更新配置 */
     updateConfig(config) {
         this.config = { ...this.config, ...config };
+        this.logger.info('Cache config updated, backend: %s', this.config.backend || 'local');
     }
     /** 设置基础URL */
     setBaseUrl(url) {
@@ -125,57 +132,95 @@ class CacheService {
     }
     /** 检查缓存是否启用 */
     isEnabled() {
-        return this.config.enabled;
+        return this.config.enabled && this.config.backend !== 'none';
+    }
+    /** 获取当前后端类型 */
+    getBackend() {
+        return this.config.backend || 'local';
     }
-    /** 获取完整配置（供中间件使用） */
+    /** 获取完整配置 */
     getConfig() {
         return this.config;
     }
+    /** 转换为 S3 配置 */
+    toS3Config() {
+        return {
+            endpoint: this.config.s3Endpoint,
+            region: this.config.s3Region,
+            accessKeyId: this.config.s3AccessKeyId,
+            secretAccessKey: this.config.s3SecretAccessKey,
+            bucket: this.config.s3Bucket,
+            publicBaseUrl: this.config.s3PublicBaseUrl,
+            forcePathStyle: this.config.s3ForcePathStyle,
+            acl: this.config.s3Acl
+        };
+    }
+    /** 转换为 WebDAV 配置 */
+    toWebDavConfig() {
+        return {
+            endpoint: this.config.webdavEndpoint,
+            username: this.config.webdavUsername,
+            password: this.config.webdavPassword,
+            basePath: this.config.webdavBasePath,
+            publicBaseUrl: this.config.webdavPublicBaseUrl
+        };
+    }
     /**
-     * 缓存文件到本地
-     * @param data 文件数据
-     * @param mime MIME 类型
-     * @param filename 文件名
-     * @param sourceUrl 可选的源 URL（用于 sourceHash 去重）
+     * 缓存文件
+     * 根据配置的后端自动选择存储方式
      */
     async cache(data, mime, filename, sourceUrl) {
         if (!this.config.enabled) {
             throw new Error('Cache is disabled');
         }
         const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        const sizeMB = buffer.length / (1024 * 1024);
-        if (sizeMB > this.config.maxFileSize) {
-            throw new Error(`File too large: ${sizeMB.toFixed(2)}MB > ${this.config.maxFileSize}MB`);
+        const backend = this.config.backend || 'local';
+        // 检查文件大小（仅本地模式限制）
+        if (backend === 'local') {
+            const sizeMB = buffer.length / (1024 * 1024);
+            if (sizeMB > this.config.maxFileSize) {
+                throw new Error(`File too large: ${sizeMB.toFixed(2)}MB > ${this.config.maxFileSize}MB`);
+            }
         }
         // 计算内容哈希
         const contentHash = this.generateContentHash(buffer);
         // 检查是否已有相同内容的缓存
         const existingByContent = await this.findByContentHash(contentHash);
         if (existingByContent) {
-            // 更新访问时间
             await this.updateAccessTime(existingByContent.contentHash);
             this.logger.debug('Cache hit by content hash: %s', contentHash);
             return this.dbRecordToCachedFile(existingByContent);
         }
-        // 确保有足够空间
-        await this.ensureCacheSpace(buffer.length);
-        // 写入文件
+        // 根据后端存储文件
         const ext = this.getExtension(mime, filename);
-        const localPath = path.join(this.cacheRoot, `${contentHash}${ext}`);
-        fs.writeFileSync(localPath, buffer);
+        const storageKey = `${contentHash}${ext}`;
+        let cachedUrl;
+        switch (backend) {
+            case 'local':
+                cachedUrl = await this.storeLocal(buffer, storageKey, contentHash, ext);
+                break;
+            case 's3':
+                cachedUrl = await this.storeS3(buffer, storageKey, mime);
+                break;
+            case 'webdav':
+                cachedUrl = await this.storeWebDav(buffer, storageKey, mime);
+                break;
+            case 'none':
+                throw new Error('Storage backend is set to none');
+            default:
+                throw new Error(`Unknown storage backend: ${backend}`);
+        }
         // 计算源哈希（如果有源 URL）
         const sourceHash = sourceUrl ? this.generateSourceHash(sourceUrl) : contentHash;
-        // 生成访问 URL
-        const cachedUrl = this.buildUrl(contentHash, ext);
         // 保存到数据库
         const now = new Date();
         await this.ctx.database.create('medialuna_asset_cache', {
             sourceUrl: sourceUrl || '',
             sourceHash,
             contentHash,
-            backend: 'local',
+            backend,
             cachedUrl,
-            cachedKey: `${contentHash}${ext}`,
+            cachedKey: storageKey,
             mimeType: mime,
             fileSize: buffer.length,
             createdAt: now,
@@ -188,24 +233,51 @@ class CacheService {
             size: buffer.length,
             createdAt: now,
             accessedAt: now,
-            localPath,
-            url: cachedUrl
+            localPath: path.join(this.cacheRoot, storageKey),
+            url: cachedUrl,
+            backend
         };
         // 更新内存缓存
         this.memoryCache.set(contentHash, cached);
-        this.logger.debug('Cached file: %s (%s, %sMB)', contentHash, cached.filename, sizeMB.toFixed(2));
+        this.logger.debug('Cached file to %s: %s', backend, contentHash);
         return cached;
     }
+    /** 存储到本地 */
+    async storeLocal(buffer, storageKey, contentHash, ext) {
+        // 确保有足够空间
+        await this.ensureCacheSpace(buffer.length);
+        const localPath = path.join(this.cacheRoot, storageKey);
+        fs.writeFileSync(localPath, buffer);
+        return this.buildLocalUrl(contentHash, ext);
+    }
+    /** 存储到 S3 */
+    async storeS3(buffer, storageKey, mime) {
+        const s3Config = this.toS3Config();
+        if (!s3Config.bucket)
+            throw new Error('S3 缺少 bucket 配置');
+        if (!s3Config.accessKeyId || !s3Config.secretAccessKey)
+            throw new Error('S3 需提供访问凭证');
+        const result = await (0, s3_1.uploadToS3)(buffer, storageKey, mime, s3Config);
+        return result.url;
+    }
+    /** 存储到 WebDAV */
+    async storeWebDav(buffer, storageKey, mime) {
+        const webdavConfig = this.toWebDavConfig();
+        if (!webdavConfig.endpoint)
+            throw new Error('WebDAV 缺少端点配置');
+        if (!webdavConfig.username || !webdavConfig.password)
+            throw new Error('WebDAV 需提供用户名和密码');
+        const result = await (0, webdav_1.uploadToWebDav)(buffer, storageKey, mime, webdavConfig);
+        return result.url;
+    }
     /**
      * 从 URL 下载并缓存
-     * 支持 sourceHash 去重：相同 URL 不会重复下载
      */
     async cacheFromUrl(url) {
         // 先检查是否已有相同源 URL 的缓存
         const sourceHash = this.generateSourceHash(url);
         const existingBySource = await this.findBySourceHash(sourceHash);
         if (existingBySource) {
-            // 更新访问时间
             await this.updateAccessTime(existingBySource.contentHash);
             this.logger.debug('Cache hit by source hash: %s -> %s', url, sourceHash);
             return this.dbRecordToCachedFile(existingBySource);
@@ -216,7 +288,6 @@ class CacheService {
         });
         const mime = this.guessMimeFromUrl(url);
         const filename = url.split('/').pop()?.split('?')[0] || 'downloaded';
-        // 缓存时传入源 URL
         return this.cache(response, mime, filename, url);
     }
     /** 获取缓存文件的访问URL */
@@ -224,39 +295,40 @@ class CacheService {
         const cached = this.memoryCache.get(id);
         if (!cached)
             return null;
-        if (cached.url)
-            return cached.url;
-        const ext = path.extname(cached.localPath);
-        return this.buildUrl(id, ext);
+        return cached.url || null;
     }
     /** 获取缓存文件信息 */
     async get(id) {
-        // 先查内存缓存
         let cached = this.memoryCache.get(id);
         if (!cached) {
-            // 查数据库
             const record = await this.findByContentHash(id);
             if (!record)
                 return null;
             cached = this.dbRecordToCachedFile(record);
             this.memoryCache.set(id, cached);
         }
-        // 检查文件是否存在
-        if (!fs.existsSync(cached.localPath)) {
-            await this.deleteFromDatabase(id);
-            this.memoryCache.delete(id);
-            return null;
+        // 如果是本地存储，检查文件是否存在
+        if (cached.backend === 'local' || !cached.backend) {
+            if (!fs.existsSync(cached.localPath)) {
+                await this.deleteFromDatabase(id);
+                this.memoryCache.delete(id);
+                return null;
+            }
         }
-        // 更新访问时间
         await this.updateAccessTime(id);
         cached.accessedAt = new Date();
         return cached;
     }
-    /** 读取缓存文件内容 */
+    /** 读取缓存文件内容（仅本地存储可用） */
     async read(id) {
         const cached = await this.get(id);
         if (!cached)
             return null;
+        // 只有本地存储可以直接读取
+        if (cached.backend !== 'local' && cached.backend) {
+            this.logger.warn('Cannot read non-local cache: %s (backend: %s)', id, cached.backend);
+            return null;
+        }
         try {
             return fs.readFileSync(cached.localPath);
         }
@@ -265,7 +337,7 @@ class CacheService {
             return null;
         }
     }
-    /** 读取为 Data URL */
+    /** 读取为 Data URL（仅本地存储可用） */
     async readAsDataUrl(id) {
         const cached = await this.get(id);
         if (!cached)
@@ -278,14 +350,17 @@ class CacheService {
     /** 删除缓存文件 */
     async delete(id) {
         const cached = this.memoryCache.get(id);
-        try {
-            // 删除本地文件
-            if (cached && fs.existsSync(cached.localPath)) {
-                fs.unlinkSync(cached.localPath);
+        if (!cached) {
+            const record = await this.findByContentHash(id);
+            if (record) {
+                await this.deleteFromBackend(record.cachedKey, record.backend);
+                await this.deleteFromDatabase(id);
             }
-            // 从数据库删除
+            return true;
+        }
+        try {
+            await this.deleteFromBackend(cached.filename, cached.backend || 'local');
             await this.deleteFromDatabase(id);
-            // 从内存缓存删除
             this.memoryCache.delete(id);
             return true;
         }
@@ -294,6 +369,46 @@ class CacheService {
             return false;
         }
     }
+    /** 从后端删除文件 */
+    async deleteFromBackend(key, backend) {
+        switch (backend) {
+            case 'local':
+                const localPath = path.join(this.cacheRoot, key);
+                if (fs.existsSync(localPath)) {
+                    fs.unlinkSync(localPath);
+                }
+                break;
+            case 's3':
+                try {
+                    await (0, s3_1.deleteFromS3)(key, this.toS3Config());
+                }
+                catch (e) {
+                    this.logger.warn('Failed to delete from S3: %s', e);
+                }
+                break;
+            case 'webdav':
+                try {
+                    await this.deleteFromWebDav(key);
+                }
+                catch (e) {
+                    this.logger.warn('Failed to delete from WebDAV: %s', e);
+                }
+                break;
+        }
+    }
+    /** 从 WebDAV 删除 */
+    async deleteFromWebDav(key) {
+        const config = this.toWebDavConfig();
+        const remotePath = config.basePath
+            ? `${config.basePath.replace(/\/+$/, '')}/${key}`
+            : key;
+        const url = `${config.endpoint.replace(/\/+$/, '')}/${remotePath.split('/').map(encodeURIComponent).join('/')}`;
+        const auth = Buffer.from(`${config.username}:${config.password}`, 'utf8').toString('base64');
+        await fetch(url, {
+            method: 'DELETE',
+            headers: { Authorization: `Basic ${auth}` }
+        });
+    }
     /** 获取统计信息 */
     async getStats() {
         const records = await this.ctx.database.get('medialuna_asset_cache', {});
@@ -312,43 +427,61 @@ class CacheService {
             totalSizeMB: totalSize / (1024 * 1024),
             maxSizeMB: this.config.maxCacheSize,
             oldestAccess: oldest,
-            newestAccess: newest
+            newestAccess: newest,
+            backend: this.config.backend || 'local'
         };
     }
     /** 清空所有缓存 */
     async clearAll() {
-        // 获取所有缓存记录
         const records = await this.ctx.database.get('medialuna_asset_cache', {});
-        // 删除所有本地文件
         for (const record of records) {
-            const localPath = path.join(this.cacheRoot, record.cachedKey);
-            try {
-                if (fs.existsSync(localPath)) {
-                    fs.unlinkSync(localPath);
-                }
-            }
-            catch (e) {
-                this.logger.warn('Failed to delete file: %s', localPath);
-            }
+            await this.deleteFromBackend(record.cachedKey, record.backend);
         }
-        // 清空数据库
         await this.ctx.database.remove('medialuna_asset_cache', {});
-        // 清空内存缓存
         this.memoryCache.clear();
         this.logger.info('All cache cleared');
     }
+    /**
+     * 测试存储连接
+     */
+    async testConnection() {
+        const backend = this.config.backend || 'local';
+        if (backend === 'none') {
+            return { success: true, message: '存储后端设置为"不使用"，无需测试' };
+        }
+        const testContent = `Media Luna Storage Test - ${new Date().toISOString()}`;
+        const testBuffer = Buffer.from(testContent, 'utf-8');
+        const testFilename = `_test-${Date.now()}.txt`;
+        const testMime = 'text/plain';
+        const startTime = Date.now();
+        try {
+            const cached = await this.cache(testBuffer, testMime, testFilename);
+            const duration = Date.now() - startTime;
+            // 清理测试文件
+            await this.delete(cached.id);
+            return {
+                success: true,
+                message: `存储连接测试成功（耗时 ${duration}ms）`,
+                url: cached.url,
+                duration
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
     // ========== 数据库操作方法 ==========
-    /** 通过 sourceHash 查找缓存 */
     async findBySourceHash(sourceHash) {
         const records = await this.ctx.database.get('medialuna_asset_cache', { sourceHash });
         return records[0] || null;
     }
-    /** 通过 contentHash 查找缓存 */
     async findByContentHash(contentHash) {
         const records = await this.ctx.database.get('medialuna_asset_cache', { contentHash });
         return records[0] || null;
     }
-    /** 更新访问时间 */
     async updateAccessTime(contentHash) {
         try {
             await this.ctx.database.set('medialuna_asset_cache', { contentHash }, {
@@ -359,11 +492,9 @@ class CacheService {
             this.logger.warn('Failed to update access time: %s', e);
         }
     }
-    /** 从数据库删除 */
     async deleteFromDatabase(contentHash) {
         await this.ctx.database.remove('medialuna_asset_cache', { contentHash });
     }
-    /** 将数据库记录转换为 CachedFile */
     dbRecordToCachedFile(record) {
         const localPath = path.join(this.cacheRoot, record.cachedKey);
         return {
@@ -374,7 +505,8 @@ class CacheService {
             createdAt: record.createdAt,
             accessedAt: record.lastAccessedAt,
             localPath,
-            url: record.cachedUrl
+            url: record.cachedUrl,
+            backend: record.backend
         };
     }
     // ========== 私有工具方法 ==========
@@ -383,12 +515,10 @@ class CacheService {
             fs.mkdirSync(dir, { recursive: true });
         }
     }
-    /** 生成内容哈希（基于文件内容） */
     generateContentHash(data) {
         const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
         return crypto.createHash('sha256').update(buffer).digest('hex').slice(0, 16);
     }
-    /** 生成源哈希（基于 URL） */
     generateSourceHash(url) {
         return crypto.createHash('sha256').update(url).digest('hex').slice(0, 16);
     }
@@ -398,22 +528,7 @@ class CacheService {
             if (ext)
                 return ext;
         }
-        return this.getExtensionFromMime(mime);
-    }
-    getExtensionFromMime(mime) {
-        const mimeMap = {
-            'image/jpeg': '.jpg',
-            'image/png': '.png',
-            'image/gif': '.gif',
-            'image/webp': '.webp',
-            'image/svg+xml': '.svg',
-            'audio/mpeg': '.mp3',
-            'audio/wav': '.wav',
-            'audio/ogg': '.ogg',
-            'video/mp4': '.mp4',
-            'video/webm': '.webm'
-        };
-        return mimeMap[mime] || '.bin';
+        return (0, mime_1.getExtensionFromMime)(mime);
     }
     guessMimeFromUrl(url) {
         const ext = url.split('.').pop()?.toLowerCase()?.split('?')[0];
@@ -432,49 +547,38 @@ class CacheService {
         };
         return mimeMap[ext || ''] || 'application/octet-stream';
     }
-    /** 构建访问 URL */
-    buildUrl(id, ext) {
-        // 优先使用配置的 publicBaseUrl
+    /** 构建本地访问 URL */
+    buildLocalUrl(id, ext) {
         if (this.publicBaseUrl) {
             return `${this.publicBaseUrl}/${id}${ext}`;
         }
-        // 否则使用 selfUrl + publicPath
         if (!this.baseUrl) {
             try {
-                // 尝试从 server 服务获取 selfUrl
                 const server = this.ctx.get?.('server');
                 const selfUrl = server?.config?.selfUrl;
                 if (selfUrl) {
                     this.baseUrl = selfUrl.replace(/\/$/, '');
-                    this.logger.debug('Base URL dynamically set to: %s', this.baseUrl);
                 }
                 else {
-                    // 如果没有配置 selfUrl，尝试使用 localhost + 端口
                     const port = server?.config?.port || 5140;
                     this.baseUrl = `http://127.0.0.1:${port}`;
-                    this.logger.debug('Base URL set to localhost: %s', this.baseUrl);
                 }
             }
             catch {
-                // 忽略错误，使用默认值
                 this.baseUrl = 'http://127.0.0.1:5140';
             }
         }
         if (!this.baseUrl) {
-            // 返回相对路径作为降级
-            this.logger.debug('Base URL not set, returning relative path for cache: %s', id);
             return `${this.publicPath}/${id}${ext}`;
         }
         return `${this.baseUrl}${this.publicPath}/${id}${ext}`;
     }
     async ensureCacheSpace(needed) {
         const maxBytes = this.config.maxCacheSize * 1024 * 1024;
-        // 从数据库获取当前缓存大小
-        const records = await this.ctx.database.get('medialuna_asset_cache', {});
+        const records = await this.ctx.database.get('medialuna_asset_cache', { backend: 'local' });
         let currentSize = records.reduce((sum, r) => sum + r.fileSize, 0);
         if (currentSize + needed <= maxBytes)
             return;
-        // 按访问时间排序，删除最旧的
         const sorted = [...records].sort((a, b) => a.lastAccessedAt.getTime() - b.lastAccessedAt.getTime());
         for (const record of sorted) {
             if (currentSize + needed <= maxBytes)
@@ -489,8 +593,7 @@ class CacheService {
         const now = new Date();
         const expireMs = this.config.expireDays * 24 * 60 * 60 * 1000;
         const expireDate = new Date(now.getTime() - expireMs);
-        // 查询过期的缓存
-        const records = await this.ctx.database.get('medialuna_asset_cache', {});
+        const records = await this.ctx.database.get('medialuna_asset_cache', { backend: 'local' });
         const toDelete = records.filter(r => r.lastAccessedAt < expireDate);
         for (const record of toDelete) {
             await this.delete(record.contentHash);