feat:完成通用代理功能

Author: Taois

controllers/file-proxy.js

@@ -4,10 +4,17 @@
  * @module file-proxy-controller
  */
 
-import {ENV} from '../utils/env.js';
-import https from 'https';
-import http from 'http';
-import {URL} from 'url';
+import {
+    createHealthResponse,
+    createStatusResponse,
+    decodeParam,
+    forwardResponseHeaders,
+    getDefaultHeaders,
+    makeRemoteRequest,
+    PROXY_CONSTANTS,
+    setCorsHeaders,
+    verifyAuth
+} from '../utils/proxy-util.js';
 
 /**
  * 远程文件代理控制器插件
@@ -18,186 +25,23 @@ import {URL} from 'url';
 export default (fastify, options, done) => {
     // 请求缓存
     const requestCache = new Map();
-    // 缓存超时时间（5分钟）
-    const cacheTimeout = 5 * 60 * 1000;
-
-    /**
-     * 验证身份认证
-     * @param {Object} request - Fastify请求对象
-     * @param {Object} reply - Fastify响应对象
-     * @returns {boolean} 验证是否通过
-     */
-    function verifyAuth(request, reply) {
-        const requiredAuth = ENV.get('PROXY_AUTH', 'drpys');
-        const providedAuth = request.query.auth;
-        
-        if (!providedAuth || providedAuth !== requiredAuth) {
-            reply.status(401).send({
-                error: 'Unauthorized',
-                message: 'Missing or invalid auth parameter',
-                code: 401
-            });
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * 解码参数 - 支持 base64 解码
-     * @param {string} param - 需要解码的参数
-     * @param {boolean} isJson - 是否为 JSON 格式
-     * @returns {string|Object} 解码后的参数
-     */
-    function decodeParam(param, isJson = false) {
-        if (!param) return isJson ? {} : '';
-
-        let decoded = param;
-
-        try {
-            // 首先尝试 URL 解码
-            decoded = decodeURIComponent(param);
-        } catch (e) {
-            // URL 解码失败，使用原始参数
-            decoded = param;
-        }
-
-        // 对于 URL 参数，如果不是 http 开头，尝试 base64 解码
-        if (!isJson && !decoded.startsWith('http://') && !decoded.startsWith('https://')) {
-            try {
-                const base64Decoded = Buffer.from(decoded, 'base64').toString('utf8');
-                if (base64Decoded.startsWith('http://') || base64Decoded.startsWith('https://')) {
-                    decoded = base64Decoded;
-                }
-            } catch (e) {
-                // base64 解码失败，保持原值
-            }
-        }
-
-        // 对于 headers 参数，如果不是 JSON 格式，尝试 base64 解码
-        if (isJson && !decoded.startsWith('{') && !decoded.endsWith('}')) {
-            try {
-                const base64Decoded = Buffer.from(decoded, 'base64').toString('utf8');
-                if (base64Decoded.startsWith('{') && base64Decoded.endsWith('}')) {
-                    decoded = base64Decoded;
-                }
-            } catch (e) {
-                // base64 解码失败，保持原值
-            }
-        }
-
-        // 如果是 JSON 格式，尝试解析
-        if (isJson) {
-            try {
-                return JSON.parse(decoded);
-            } catch (e) {
-                console.warn('Failed to parse headers as JSON:', decoded);
-                return {};
-            }
-        }
-
-        return decoded;
-    }
-
-    /**
-     * 获取默认请求头
-     * @param {Object} request - Fastify 请求对象
-     * @returns {Object} 默认请求头
-     */
-    function getDefaultHeaders(request) {
-        const defaultHeaders = {};
-
-        // 复制一些重要的请求头
-        const headersToForward = [
-            'user-agent',
-            'accept',
-            'accept-language',
-            'accept-encoding',
-            'referer',
-            'origin'
-        ];
-
-        headersToForward.forEach(header => {
-            if (request.headers[header]) {
-                defaultHeaders[header] = request.headers[header];
-            }
-        });
-
-        // 如果没有 user-agent，设置默认值
-        if (!defaultHeaders['user-agent']) {
-            defaultHeaders['user-agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36';
-        }
-
-        return defaultHeaders;
-    }
-
-    /**
-     * 发起远程请求
-     * @param {string} url - 远程文件 URL
-     * @param {Object} headers - 请求头
-     * @param {string} method - 请求方法
-     * @param {string} range - Range 头
-     * @returns {Promise} 请求结果
-     */
-    function makeRemoteRequest(url, headers, method = 'GET', range = null) {
-        return new Promise((resolve, reject) => {
-            try {
-                const urlObj = new URL(url);
-                const isHttps = urlObj.protocol === 'https:';
-                const httpModule = isHttps ? https : http;
-
-                const requestHeaders = { ...headers };
-                if (range) {
-                    requestHeaders['range'] = range;
-                }
-
-                const options = {
-                    hostname: urlObj.hostname,
-                    port: urlObj.port || (isHttps ? 443 : 80),
-                    path: urlObj.pathname + urlObj.search,
-                    method: method,
-                    headers: requestHeaders,
-                    timeout: 30000 // 30秒超时
-                };
-
-                const req = httpModule.request(options, (res) => {
-                    resolve({
-                        statusCode: res.statusCode,
-                        headers: res.headers,
-                        stream: res
-                    });
-                });
-
-                req.on('error', (error) => {
-                    reject(new Error(`Request failed: ${error.message}`));
-                });
-
-                req.on('timeout', () => {
-                    req.destroy();
-                    reject(new Error('Request timeout'));
-                });
-
-                req.end();
-            } catch (error) {
-                reject(new Error(`Invalid URL or request setup: ${error.message}`));
-            }
-        });
-    }
 
     /**
      * 远程文件代理健康检查接口
      * GET /file-proxy/health - 检查远程文件代理服务状态
      */
     fastify.get('/file-proxy/health', async (request, reply) => {
-        console.log(`[fileProxyController] Health check request`);
-
-        return reply.send({
-            status: 'ok',
-            service: 'Remote File Proxy',
-            timestamp: new Date().toISOString(),
+        // console.log(`[fileProxyController] Health check request`);
+        
+        setCorsHeaders(reply);
+        
+        const healthData = createHealthResponse('Remote File Proxy', {
             cache: {
                 requests: requestCache.size
             }
         });
+        
+        return reply.send(healthData);
     });
 
     /**
@@ -215,7 +59,7 @@ export default (fastify, options, done) => {
 
             const { url: urlParam, headers: headersParam } = request.query;
 
-            console.log(`[fileProxyController] ${request.method} request for URL: ${urlParam}`);
+            // console.log(`[fileProxyController] ${request.method} request for URL: ${urlParam}`);
 
             // 验证必需参数
             if (!urlParam) {
@@ -260,28 +104,9 @@ export default (fastify, options, done) => {
                     // 设置响应状态码
                     reply.status(remoteResponse.statusCode);
 
-                    // 转发重要的响应头
-                    const headersToForward = [
-                        'content-type',
-                        'content-length',
-                        'content-range',
-                        'accept-ranges',
-                        'last-modified',
-                        'etag',
-                        'cache-control',
-                        'expires'
-                    ];
-
-                    headersToForward.forEach(header => {
-                        if (remoteResponse.headers[header]) {
-                            reply.header(header, remoteResponse.headers[header]);
-                        }
-                    });
-
-                    // 设置 CORS 头
-                    reply.header('Access-Control-Allow-Origin', '*');
-                    reply.header('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS');
-                    reply.header('Access-Control-Allow-Headers', 'Range, Content-Type');
+                    // 转发响应头和设置CORS
+                    forwardResponseHeaders(reply, remoteResponse.headers);
+                    setCorsHeaders(reply);
 
                     // 对于 HEAD 请求，只返回头部信息
                     if (request.method === 'HEAD') {
@@ -317,7 +142,7 @@ export default (fastify, options, done) => {
 
         const { url: urlParam, headers: headersParam } = request.query;
 
-        console.log(`[fileProxyController] Info request for URL: ${urlParam}`);
+        // console.log(`[fileProxyController] Info request for URL: ${urlParam}`);
 
         // 验证必需参数
         if (!urlParam) {
@@ -379,85 +204,38 @@ export default (fastify, options, done) => {
     });
 
     /**
-     * 缓存管理接口
-     * DELETE /file-proxy/cache - 清理缓存
+     * 清理缓存路由
      */
     fastify.delete('/file-proxy/cache', async (request, reply) => {
-        // 验证身份认证
-        if (!verifyAuth(request, reply)) {
-            return;
-        }
+        if (!verifyAuth(request, reply)) return;
 
-        console.log(`[fileProxyController] Cache clear request`);
+        setCorsHeaders(reply);
 
-        try {
-            // 非VERCEL环境可在设置中心控制此功能是否开启
-            if (!process.env.VERCEL) {
-                if (!Number(process.env.allow_file_cache_clear)) {
-                    return reply.status(403).send({ error: 'Cache clear is not allowed by owner' });
-                }
-            }
-
-            const cacheCount = requestCache.size;
-
-            // 清理缓存
-            requestCache.clear();
-
-            return reply.send({
-                success: true,
-                message: 'Cache cleared successfully',
-                cleared: {
-                    requests: cacheCount
-                }
-            });
-        } catch (error) {
-            console.error('[fileProxyController] Cache clear error:', error);
-            return reply.status(500).send({ error: error.message });
-        }
+        const beforeSize = requestCache.size;
+        requestCache.clear();
+        
+        reply.send({
+            status: 'success',
+            message: 'Cache cleared',
+            cleared: beforeSize,
+            timestamp: new Date().toISOString()
+        });
     });
 
     /**
-     * 远程文件代理状态接口
-     * GET /file-proxy/status - 获取代理服务状态
+     * 状态路由
      */
     fastify.get('/file-proxy/status', async (request, reply) => {
-        console.log(`[fileProxyController] Status request`);
-
-        try {
-            return reply.send({
-                service: 'Remote File Proxy Controller',
-                version: '1.0.0',
-                status: 'running',
-                cache: {
-                    requests: requestCache.size,
-                    timeout: cacheTimeout
-                },
-                features: [
-                    'Remote file proxying',
-                    'Base64 parameter decoding',
-                    'Range request support',
-                    'Custom headers support',
-                    'CORS support',
-                    'Authentication protection'
-                ],
-                endpoints: [
-                    'GET /file-proxy/health - Health check (no auth required)',
-                    'GET /file-proxy/proxy?url=<remote_url>&auth=<auth_code>&headers=<custom_headers> - Proxy remote file',
-                    'HEAD /file-proxy/proxy?url=<remote_url>&auth=<auth_code>&headers=<custom_headers> - Get remote file headers',
-                    'GET /file-proxy/info?url=<remote_url>&auth=<auth_code>&headers=<custom_headers> - Get remote file information',
-                    'DELETE /file-proxy/cache?auth=<auth_code> - Clear cache',
-                    'GET /file-proxy/status - Get service status (no auth required)'
-                ],
-                auth: {
-                    required: true,
-                    parameter: 'auth',
-                    description: 'Authentication code required for protected endpoints'
-                }
-            });
-        } catch (error) {
-            console.error('[fileProxyController] Status request error:', error);
-            return reply.status(500).send({ error: error.message });
-        }
+        setCorsHeaders(reply);
+        
+        const statusData = createStatusResponse('file-proxy', '1.0.0', {
+            cache: {
+                size: requestCache.size,
+                timeout: PROXY_CONSTANTS.CACHE_TIMEOUT
+            }
+        });
+        
+        reply.send(statusData);
     });
 
     done();