ql-publish 0.0.1

package/cdn/index.js

@@ -0,0 +1,4 @@
+const refreshCdn = require('./refresh');
+const config = require('../config/config')[process.env.NODE_ENV];
+
+refreshCdn(config.cdn.list);

package/cdn/refresh.js

@@ -0,0 +1,45 @@
+const $CDN = require('@alicloud/cdn20180510');
+const $OpenApi = require('@alicloud/openapi-client');
+const logger = require('../utils/logger');
+const cdnConfig = require('../config/config')[process.env.NODE_ENV];
+
+/**
+ * 使用凭据初始化账号Client
+ * @return Client
+ * @throws Exception
+ */
+const createClient = () => {
+    let config = new $OpenApi.Config({
+        // AccessKey ID
+        accessKeyId: cdnConfig.cdn.accessKeyId,
+        // AccessKey Secret
+        accessKeySecret: cdnConfig.cdn.accessKeySecret,
+        endpoint: cdnConfig.cdn.endpoint,
+    });
+    return new $CDN.default(config);
+}
+
+/**
+ *
+ * @param list
+ * @returns {Promise<void>}
+ */
+const run = async (list = []) => {
+    logger.warn('开始刷新CDN...')
+    let client = createClient();
+    for (const item of list) {
+        let req = new $CDN.RefreshObjectCachesRequest({
+            objectType: item.type,
+            objectPath: item.url
+        });
+        let resp = await client.refreshObjectCaches(req).catch((err) => {
+            logger.error("❌刷新CDN缓存失败");
+            logger.error(err);
+        });
+        logger.success("✅ 刷新CDN缓存成功--------------------\n");
+        logger.warn(`url：${item.url}\n`);
+        logger.info({ statusCode: resp.statusCode, body: resp.body, date: resp.headers.date });
+    }
+}
+
+module.exports = run;

package/config/config.js

@@ -0,0 +1,69 @@
+const { _config, coreConfig } = require('./index');
+
+const ossConfigCdn = () => {
+    if (!_config[process.env.NODE_ENV].cdn) return {};
+    return {
+        cdn: {
+            accessKeyId: coreConfig.cdn.accessKeyId,
+            accessKeySecret: coreConfig.cdn.accessKeySecret,
+            endpoint: coreConfig.cdn.endpoint,
+            list: _config[process.env.NODE_ENV].cdn,
+        }
+    }
+}
+
+// 服务器配置信息
+module.exports = {
+    test: {
+        localPath: _config.test.localPath,
+        host: coreConfig.test.host,
+        port: coreConfig.test.port,
+        username: coreConfig.test.username,
+        // 私钥路径
+        privateKey: coreConfig.test.privateKey,
+        // 项目旧版本代码保存最近3个月备份
+        backUpSeconds: _config.test.backUpSeconds,
+        // 如果私钥有密码，需要提供
+        // passphrase: 'your-passphrase', 
+        // 服务器上的部署路径
+        path: _config.test.path,
+        // 是否备份
+        backUp: _config.test.backUp,
+    },
+    pro: {
+        localPath: _config.pro.localPath,
+        host: coreConfig.pro.host,
+        port: coreConfig.pro.port,
+        username: coreConfig.pro.username,
+        // 私钥路径
+        privateKey: coreConfig.pro.privateKey,
+        // 项目旧版本代码保存最近3个月备份
+        backUpSeconds: _config.pro.backUpSeconds,
+        // 如果私钥有密码，需要提供
+        // passphrase: 'your-passphrase', 
+        // 服务器上的部署路径
+        path: _config.pro.path,
+        // 是否备份
+        backUp: _config.pro.backUp,
+        // cdn 配置
+        ...ossConfigCdn(),
+    },
+    // 生产oss配置
+    oss: {
+        accessKeyId: coreConfig.oss.accessKeyId,
+        accessKeySecret: coreConfig.oss.accessKeySecret,
+        region: coreConfig.oss.region,
+        bucket: coreConfig.oss.bucket,
+        // 本地打包后的文件夹路径
+        localDir: _config.oss.localDir,
+        // 上传到OSS的目标路径，默认为根目录
+        targetDir: _config.oss.targetDir,
+
+        // 项目旧版本代码保存最近3个月备份
+        backUpSeconds: _config.oss.backUpSeconds,
+        // 是否备份
+        backUp: _config.pro.backUp,
+        // cdn 配置
+        ...ossConfigCdn(),
+    }
+};

package/config/index.js

@@ -0,0 +1,7 @@
+let _config = {};
+let coreConfig = {};
+
+module.exports = {
+    _config,
+    coreConfig
+}

package/index.js

@@ -0,0 +1,17 @@
+let { _config, coreConfig } = require('./config/index')
+
+module.exports = {
+    initConfig: (config, _coreConfig) => {
+        _config = config;
+        coreConfig = _coreConfig;
+    },
+    clear: () => {
+
+    },
+    upload: () => {
+        return require('./upload/index')();
+    },
+    refresh: () => {
+
+    }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "ql-publish",
+    "version": "0.0.1",
+    "scripts": {},
+    "dependencies": {
+        "@alicloud/cdn20180510": "^7.0.1",
+        "@alicloud/openapi-client": "^0.4.14",
+        "ali-oss": "^6.23.0",
+        "cross-env": "^10.0.0",
+        "dayjs": "^1.11.11",
+        "readline": "^1.3.0",
+        "scp2": "^0.5.0",
+        "ssh2": "^1.16.0"
+    },
+    "devDependencies": {},
+    "main": "index.js",
+    "keywords": [
+        "auto Publish",
+        "ql"
+    ],
+    "author": "Jresun",
+    "license": "ISC",
+    "description": ""
+}

package/upload/clear.js

@@ -0,0 +1,159 @@
+const config = require('../config/config.js')[process.env.NODE_ENV];
+const logger = require('../utils/logger');
+const { Client } = require('ssh2');
+const readline = require("readline");
+const path = require("path");
+
+const readStreamByFile = async (sftp, remoteFilePath) => {
+    return new Promise((resolve) => {
+        console.log(`准备读取文件: ${remoteFilePath}`);
+
+        // 创建读取流
+        const readStream = sftp.createReadStream(remoteFilePath, {
+            encoding: 'utf8' // 以UTF-8编码读取
+        });
+
+        let fileContent = '';
+
+        // 收集文件内容
+        readStream.on('data', (chunk) => {
+            fileContent += chunk;
+        });
+
+        // 读取完成处理
+        readStream.on('end', () => {
+            try {
+                // 解析JSON数据
+                const jsonData = JSON.parse(fileContent);
+                console.log('文件内容解析成功:');
+                resolve(jsonData)
+            } catch (parseErr) {
+                logger.error('JSON解析失败:', parseErr);
+                console.log('原始文件内容:', fileContent);
+                process.exit(1);
+            }
+        });
+
+        // 处理读取错误
+        readStream.on('error', (err) => {
+            logger.error('读取文件时发生错误:', err);
+            process.exit(1);
+        });
+    })
+}
+
+const isHasDir = (sftp, dirPath) => {
+    return new Promise(resolve => {
+        sftp.stat(dirPath, (err) => {
+            resolve(!err);
+        })
+    })
+}
+
+const authProjectName = () => {
+    return new Promise((resolve) => {
+        // 创建readline接口
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        // 向用户提问
+        rl.question(`${process.env.NODE_ENV}环境：是否确认删除map映射文件 ${config.path} 项目? (输入 y 继续) `, (answer) => {
+            // 检查用户输入是否为'y'（不区分大小写）
+            if (answer.trim().toLowerCase() === 'y') {
+                resolve(true);
+            } else {
+                logger.error('❌ 发布程序终止');
+                resolve(false);
+            }
+            // 关闭接口
+            rl.close();
+        });
+    })
+}
+
+const deleteFileByMapJson = async (sftp, currentSourceDir, mtime) => {
+    // 获取源目录中的所有项目
+    const items = await new Promise((resolve, reject) => {
+        sftp.readdir(currentSourceDir, (err, list) => {
+            if (err) {
+                reject(new Error(`读取目录失败 ${currentSourceDir}: ${err.message}`));
+            } else {
+                resolve(list);
+            }
+        });
+    });
+
+    // 处理每个项目
+    for (const item of items) {
+        const sourcePath = path.posix.join(currentSourceDir, item.filename);
+
+        if (item.attrs.isDirectory()) {
+            // 如果是目录，递归处理
+            await deleteFileByMapJson(sftp, sourcePath, mtime);
+        } else {
+            // 删除文件
+            if (mtime >= item.attrs.mtime) {
+                // console.log(`删除文件: ${sourcePath}`,);
+                await sftp.unlink(sourcePath);
+            }
+        }
+    }
+}
+
+async function run() {
+    if (!await authProjectName()) {
+        process.exit(1);
+    }
+
+    let conn, sftp;
+
+    try {
+        logger.warn('连接到服务器...');
+        // 连接到服务器
+        conn = new Client();
+        await new Promise((resolve, reject) => {
+            conn.on('ready', resolve);
+            conn.on('error', (err) => reject(new Error(`❌ 服务器连接失败: ${err.message}`)));
+            conn.connect(config);
+        });
+        logger.info('✅ 已成功连接到服务器');
+
+        // 初始化SFTP
+        sftp = await new Promise((resolve, reject) => {
+            conn.sftp((err, sftpClient) => {
+                if (err) {
+                    reject(new Error(`SFTP初始化失败: ${err.message}`));
+                } else {
+                    resolve(sftpClient);
+                }
+            });
+        });
+
+        // 没有项目目录，直接返回
+        if (!await isHasDir(sftp, config.path)) {
+            logger.warn('✅ 新项目，无需清理旧文件')
+            return
+        }
+        // 没有map文件，直接返回
+        if (!await isHasDir(sftp, `${config.path}/fileMap.json`)) {
+            logger.warn('✅ 没有map映射文件，无需清理旧文件')
+            return
+        }
+        const { mtime } = await readStreamByFile(sftp, `${config.path}/fileMap.json`);
+        logger.warn('正在删除文件...')
+        await deleteFileByMapJson(sftp, config.path, mtime);
+        await deleteFileByMapJson(sftp, config.path, mtime);
+        logger.success(`✅ ${process.env.NODE_ENV}环境，根据map删除映射文件成功！`)
+    } catch (err) {
+        logger.error('❌ 过程出错:', err.message);
+    } finally {
+        // 关闭连接
+        if (sftp) sftp.end();
+        if (conn) conn.end();
+        // console.log('连接已关闭');
+    }
+}
+
+run();

package/upload/index.js

@@ -0,0 +1,6 @@
+module.exports = function () {
+    process.env.NODE_ENV === 'test' && require('./u')();
+    process.env.NODE_ENV === 'pro' && require('./u')();
+    process.env.NODE_ENV === 'oss' && require('./oss')();
+}
+

package/upload/oss.js

@@ -0,0 +1,272 @@
+const config = require('../config/config.js')[process.env.NODE_ENV];
+const OSS = require('ali-oss');
+const fs = require('fs');
+const dayjs = require('dayjs');
+const logger = require('../utils/logger');
+const readline = require('readline');
+const path = require('path');
+const refreshCdn = require('../cdn/refresh')
+
+// 初始化OSS客户端
+const client = new OSS(config);
+
+const reduceLog = () => {
+    return Math.random() * 2 > 1.98
+}
+
+/**
+ * 复制OSS中的文件夹到指定目录
+ * @param {string} sourcePrefix - 源文件夹前缀（如: 'source-folder/'）
+ * @param {string} targetBucket - 目标Bucket名称（可以与源Bucket相同）
+ * @param {string} targetPrefix - 目标文件夹前缀（如: 'target-folder/'）
+ * @param {string} [delimiter=''] - 分隔符，用于列出文件夹下的文件
+ */
+async function copyFolder(sourcePrefix, targetBucket, targetPrefix, delimiter = '') {
+    try {
+        let marker = '';
+        const maxKeys = 100; // 每次最多获取100个文件，可根据需要调整
+
+        do {
+            // 列出源文件夹下的文件
+            const result = await client.list({
+                prefix: sourcePrefix,
+                marker,
+                maxKeys,
+                delimiter
+            });
+
+            // 复制文件
+            if (result.objects && result.objects.length > 0) {
+                for (let file of result.objects) {
+                    // 构建目标文件路径
+                    const targetPath = targetPrefix + file.name.replace(sourcePrefix, '');
+
+                    try {
+                        // 复制文件
+                        await client.copy(targetPath, file.name);
+                        reduceLog() && logger.log(`✅ 已复制: ${file.name} -> ${targetPath}`);
+                    } catch (err) {
+                        logger.error(`❌ 复制失败 ${file.name}:`, err.message);
+                        throw new Error(err.message)
+                    }
+                }
+            }
+
+            // 处理子目录（如果有）
+            if (result.prefixes && result.prefixes.length > 0) {
+                for (const prefix of result.prefixes) {
+                    // 递归复制子目录
+                    await copyFolder(prefix, targetBucket, targetPrefix, delimiter);
+                }
+            }
+
+            marker = result.nextMarker;
+        } while (marker);
+
+        logger.warn('🎉  文件夹复制完成');
+        return true;
+    } catch (err) {
+        logger.error('❌ 复制文件夹时发生错误:', err);
+        return false;
+    }
+}
+
+/**
+ * 删除OSS中的文件夹及其所有内容
+ * @param {string} folderPath - 要删除的文件夹路径，例如: 'test-folder/'
+ */
+async function deleteFolder(folderPath) {
+    try {
+        let nextMarker = null;
+        let deletedCount = 0;
+
+        do {
+            // 列出文件夹下的所有文件
+            const result = await client.list({
+                prefix: folderPath, // 只列出指定前缀的文件
+                marker: nextMarker, // 分页标记
+                maxKeys: 100 // 每次最多列出100个文件
+            });
+
+            // 添加检查：确保 result.objects 存在且为数组
+            if (!result.objects || result.objects.length === 0) {
+                break;
+            }
+
+            // 准备要删除的文件列表
+            const objects = result.objects.filter(obj => obj && obj.name).map(obj => obj.name);
+
+            try {
+                // 批量删除文件
+                await client.deleteMulti(objects, { quiet: false });
+            } catch (e) {
+                throw new Error(e.message)
+            }
+
+            deletedCount += objects.length;
+            nextMarker = result.nextMarker;
+
+        } while (nextMarker);
+
+        logger.warn(`✅ 成功删除文件夹 "${folderPath}" 及其 ${deletedCount} 个文件`);
+        return true;
+
+    } catch (err) {
+        logger.error('❌ 删除文件夹失败:', err);
+        throw err;
+    }
+}
+
+// 递归读取目录并上传文件
+async function uploadDir(localPath, targetPath = '') {
+    const files = fs.readdirSync(localPath);
+
+    for (const file of files) {
+        const localFilePath = path.join(localPath, file);
+        const stats = fs.statSync(localFilePath);
+
+        // 处理目标路径
+        const ossFilePath = targetPath
+            ? `${targetPath}/${file}`
+            : file;
+
+        if (stats.isDirectory()) {
+            // 如果是目录，递归处理
+            await uploadDir(localFilePath, ossFilePath);
+        } else {
+            // 如果是文件，上传到OSS
+            try {
+                await client.put(ossFilePath, localFilePath);
+                reduceLog() && logger.log(`✅ 上传成功: ${ossFilePath}`);
+            } catch (e) {
+                logger.error(`❌ 上传失败: ${ossFilePath}`, e);
+            }
+        }
+    }
+}
+
+const deleteOldBackupDir = async () => {
+    try {
+        const folderPath = `${config.targetDir}_old/`;
+        let nextMarker = null;
+
+        do {
+            // 列出文件夹下的所有文件
+            const result = await client.list({
+                prefix: folderPath, // 只列出指定前缀的文件
+                marker: nextMarker, // 分页标记
+                maxKeys: 100 // 每次最多列出100个文件
+            });
+
+            // 添加检查：确保 result.objects 存在且为数组
+            if (!result.objects || result.objects.length === 0) {
+                break;
+            }
+
+            // 准备要删除的文件列表
+            const objects = result.objects.filter(obj => {
+                if (obj && obj.name) {
+                    let fileDate = obj.name.split('/')[1].split('_');
+                    fileDate.length = 3
+                    if (!fileDate.length) return false;
+                    fileDate = fileDate.join('-');
+                    return dayjs().diff(dayjs(`${fileDate} 00:00:00`), 'seconds') > config.backUpSeconds;
+                }
+                return false;
+            }).map(obj => obj.name);
+
+            if (objects.length !== 0) {
+                try {
+                    // 批量删除文件
+                    await client.deleteMulti(objects, { quiet: false });
+                } catch (e) {
+                    throw new Error(e.message)
+                }
+            }
+            nextMarker = result.nextMarker;
+        } while (nextMarker);
+
+        logger.warn(`✅ 成功删除3个月内备份`);
+        return true;
+
+    } catch (err) {
+        logger.error('❌ 删除3个月内备份文件夹失败:', err);
+        throw err;
+    }
+}
+
+const backupDir = async () => {
+    const sourceFolder = `${config.targetDir}/`;
+    // 目标Bucket（可以与源Bucket相同）
+    const targetBucket = config.bucket;
+    // 目标文件夹（注意末尾的斜杠）
+    const targetFolder = `${config.targetDir}_old/${dayjs().format("YYYY_MM_DD_HH_mm_ss")}/`;
+    logger.info(`开始备份旧代码到 ${targetFolder} 目录`);
+    return await copyFolder(sourceFolder, targetBucket, targetFolder);
+}
+
+const authProjectName = () => {
+    return new Promise((resolve) => {
+        // 创建readline接口
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        // 向用户提问
+        rl.question(`是否确认发布 ${config.targetDir} 项目? (输入 y 继续) `, (answer) => {
+            // 检查用户输入是否为'y'（不区分大小写）
+            if (answer.trim().toLowerCase() === 'y') {
+                resolve(true);
+            } else {
+                logger.error('❌ 发布程序终止');
+                resolve(false);
+            }
+            // 关闭接口
+            rl.close();
+        });
+    })
+}
+
+// 执行上传
+async function run() {
+    if (!await authProjectName()) {
+        process.exit(1);
+    }
+
+    logger.info('开始上传到阿里云OSS...');
+
+    // 删除3个月之前的备份
+    if (!await deleteOldBackupDir()) {
+        process.exit(1);
+    }
+
+    // 备份上一次发版的代码
+    if (!await backupDir()) {
+        process.exit(1);
+    }
+
+    // 删除目标文件夹代码
+    if (!await deleteFolder(`${config.targetDir}/`)) {
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(config.localDir)) {
+        logger.error(`错误: 目录 ${config.localDir} 不存在，请先执行打包命令`);
+        process.exit(1);
+    }
+
+    try {
+        logger.info('开始上传项目文件：')
+        await uploadDir(config.localDir, config.targetDir);
+        logger.success('🎉 生产环境：所有文件上传完成!');
+
+        config.cdn && config.cdn.list && refreshCdn(config.cdn.list);
+    } catch (error) {
+        logger.error('❌ 生产环境：上传过程中发生错误:');
+        logger.error(error);
+        process.exit(1);
+    }
+}
+
+module.exports = run;