@yoooloo42/beat 1.0.25 → 1.0.26

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@yoooloo42/beat",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -22,13 +23,18 @@
     "@yoooloo42/bean": "^1.0.14",
     "aliyun-api-gateway": "^1.1.6",
     "axios": "^1.13.2",
+    "multer": "^2.0.2",
     "nodemailer": "^7.0.10",
     "xml2js": "^0.6.2"
   },
   "exports": {
     "./libs/*": "./src/libs/*.js",
     "./libs/Ali/*": "./src/libs/Ali/*.js",
-    "./libs/crypto/*": "./src/libs/crypto/*.js"
+    "./libs/crypto/*": "./src/libs/crypto/*.js",
+    "./libs/multer/*": "./src/libs/multer/*.js",
+    "./libs/readfile/*": "./src/libs/readfile/*.js",
+    "./libs/WeChat/*": "./src/libs/WeChat/*.js",
+    "./libs/WeChat-Pay/*": "./src/libs/WeChat-Pay/*.js"
   },
   "files": [
     "src"

package/src/libs/multer/clear.js

@@ -0,0 +1,81 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/**
+ * 🚀 删除指定的文件夹及其包含的所有文件和子文件夹。
+ *
+ * @param {string} folderPath - 要删除的文件夹的绝对或相对路径。
+ * @returns {Promise<void>} 一个在删除成功时解析的 Promise。
+ */
+async function deleteFolder(folderPath) {
+    // 检查路径是否存在，避免不必要的错误日志 (可选，fs.rm在路径不存在时会报错)
+    try {
+        await fs.access(folderPath);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.log(`文件夹 ${folderPath} 不存在，无需删除。`);
+            return;
+        }
+        throw error; // 抛出其他类型的文件系统错误
+    }
+
+    try {
+        console.log(`正在删除文件夹及其内容: ${folderPath}`);
+        // 使用 { recursive: true, force: true } 来递归地强制删除。
+        // force: true 忽略路径不存在时的错误。
+        await fs.rm(folderPath, { recursive: true, force: true });
+        console.log(`✅ 文件夹及其内容删除成功: ${folderPath}`);
+    } catch (error) {
+        console.error(`❌ 删除文件夹 ${folderPath} 失败:`, error);
+        throw error;
+    }
+}
+
+/**
+ * ✨ 清空指定的文件夹，但保留文件夹本身。
+ *
+ * @param {string} folderPath - 要清空的文件夹的绝对或相对路径。
+ * @returns {Promise<void>} 一个在清空成功时解析的 Promise。
+ */
+async function clearFolder(folderPath) {
+    try {
+        // 1. 读取文件夹中的所有文件和子目录名
+        const files = await fs.readdir(folderPath);
+
+        if (files.length === 0) {
+            console.log(`文件夹 ${folderPath} 已经是空的。`);
+            return;
+        }
+
+        console.log(`正在清空文件夹内容: ${folderPath}`);
+
+        // 2. 使用 Promise.all 并行删除所有内容
+        const deletePromises = files.map(file => {
+            const fullPath = path.join(folderPath, file);
+            // 对于每个项目，我们使用 fs.rm 配合 { recursive: true, force: true }。
+            // 这样无论是文件还是子文件夹，都可以被正确删除。
+            return fs.rm(fullPath, { recursive: true, force: true })
+                .then(() => console.log(`   - 已删除: ${file}`))
+                .catch(err => {
+                    console.error(`   - ❌ 无法删除 ${file}: ${err.message}`);
+                    // 决定是否抛出错误，这里我们选择记录错误但不中断整个清空过程。
+                });
+        });
+
+        await Promise.all(deletePromises);
+
+        console.log(`✅ 文件夹 ${folderPath} 内容清空成功。`);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.error(`❌ 文件夹 ${folderPath} 不存在，无法清空。`);
+        } else {
+            console.error(`❌ 清空文件夹 ${folderPath} 失败:`, error);
+        }
+        throw error;
+    }
+}
+
+export default {
+    deleteFolder,
+    clearFolder
+}

package/src/libs/multer/convert.js

@@ -0,0 +1,81 @@
+import path from 'path'
+
+/**
+ * 将本地文件系统路径转换为可访问的Web URL。
+ * * @param filePath - 待转换的本地文件系统绝对路径或相对路径。
+ * @param fileRootPath - 文件在服务器上的根存储目录，对应URL中的基础路径之前的部分。
+ * 例如: "/Users/user/project/uploads" 或 "D:\\project\\uploads"
+ * @param baseUrl - Web访问的基础URL，对应文件路径中的根存储目录。
+ * 例如: "https://api.example.com/files"
+ * @returns 转换后的Web URL字符串。
+ */
+function pathToUrl(filePath, fileRootPath, baseUrl) {
+    // 1. 统一路径分隔符 (解决 Windows/Linux 路径分隔符差异)
+    //    将所有 \ 替换为 /
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedRootPath = fileRootPath.replace(/\\/g, '/');
+
+    // 2. 确保 baseUrl 以 / 结尾 (方便拼接)
+    const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+
+    // 3. 检查文件路径是否包含文件存储根目录
+    if (!normalizedPath.startsWith(normalizedRootPath)) {
+        // 如果文件路径不在根目录下，可能需要抛出错误或返回空
+        console.error(`文件路径不在指定的根目录中：${filePath}`);
+        return null;
+    }
+
+    // 4. 提取相对路径部分 (这是路径和URL的"第二部分")
+    //    从文件路径中移除根存储目录
+    let relativePath = normalizedPath.substring(normalizedRootPath.length);
+
+    // 5. 确保相对路径以 / 开头，方便拼接
+    if (!relativePath.startsWith('/')) {
+        relativePath = '/' + relativePath;
+    }
+
+    // 6. 组合 Web URL
+    //    Web URL = ${Web访问基础URL} + ${相对路径部分}
+    const webUrl = normalizedBaseUrl + relativePath;
+
+    return webUrl;
+}
+
+/**
+ * 将Web URL转换回本地文件系统路径。
+ * * @param webUrl - 待转换的Web URL。
+ * @param fileRootPath - 文件在服务器上的根存储目录。
+ * @param baseUrl - Web访问的基础URL。
+ * @returns string
+ */
+function urlToPath(webUrl, baseUrl, fileRootPath) {
+    // 1. 确保 baseUrl 以 / 结尾 (方便统一处理)
+    const normalizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+
+    // 2. 检查URL是否包含Web访问的基础URL
+    if (!webUrl.startsWith(normalizedBaseUrl)) {
+        console.error(`URL不包含指定的Web基础路径：${webUrl}`);
+        return null;
+    }
+
+    // 3. 提取相对路径部分
+    let relativePath = webUrl.substring(normalizedBaseUrl.length);
+
+    // 4. 确保文件根目录不以 / 结尾 (Node.js的path模块更倾向于不以斜杠结尾)
+    const normalizedRootPath = fileRootPath.endsWith('/') ? fileRootPath.slice(0, -1) : fileRootPath;
+
+    // 5. 组合文件路径
+    // 注意：在组合路径时，最好使用 Node.js 内置的 path 模块，以确保跨平台兼容性
+
+    // path.join 会自动处理多余的斜杠，并使用当前系统的分隔符（Windows下会使用\）
+    // 如果您确定只需要 / 分隔符（例如在容器或Linux环境中），可以直接使用字符串拼接
+    // return normalizedRootPath + relativePath;
+
+    // 使用 path 模块（推荐）
+    return path.join(normalizedRootPath, relativePath);
+}
+
+export default {
+    pathToUrl,
+    urlToPath
+}

package/src/libs/multer/ly0.js

@@ -0,0 +1,466 @@
+import fs from 'fs'
+import path from 'path'
+const thisTime = new Date()
+
+// 图片新增
+function imageAppend (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.pathHead.uploadFolder 上传文件夹
+    // para.pathHead.uploadUrl 上传URL
+    // para.uploaded 已上传文件的URL
+
+    // para.dataunitId 数据单元ID
+    // para.tblName 表名
+    // para.fieldName 字段名
+    // para.fieldIndex 数组类型字段的索引
+    // para.dataId 数据ID
+
+    return new Promise(function (resolve, reject) {
+        if (!para.uploaded) {
+            return resolve('')
+        }
+
+        // 数据库文件夹：数据单元ID + 表名 + 字段名 + 数组类型字段的索引 + 当年 + 当月
+        const dbFolder = para.pathHead.dbFolder +
+            (para.dataunitId ? '/' + para.dataunitId : '') +
+            '/' + para.tblName +
+            '/' + para.fieldName +
+            '[' + ('fieldIndex' in para ? para.fieldIndex : 0) + "]" +
+            '/' + thisTime.getFullYear() +
+            '/' + (thisTime.getMonth() + 1)
+        // 数据库文件名：数据单元ID + 表名 + 字段名 + 数组类型字段的索引 + 数据ID + 随机数 + 扩展名
+        const dbFileName = (para.dataunitId ? para.dataunitId + '.' : '') +
+            para.tblName + '.' +
+            para.fieldName + '.' +
+            ('fieldIndex' in para ? para.fieldIndex : 0) + '.' +
+            para.dataId + '.' +
+            Math.floor((999999 - 0) * Math.random() + 0) +
+            path.parse(para.uploaded).ext
+
+        // 上传文件路径：来自于 已上传文件的URL 头部置换
+        const uploadFilePath = para.uploaded.replace(para.pathHead.uploadUrl, para.pathHead.uploadFolder)
+        // 数据库文件路径
+        const dbFilePath = dbFolder + '/' + dbFileName
+        // 数据库URL：来自于 数据库文件夹中的文件路径 头部置换
+        const dbUrl = dbFilePath.replace(para.pathHead.dbFolder, para.pathHead.dbUrl)
+        new Promise(function (resolve, reject) {
+            // 创建数据库文件夹
+            fs.mkdir(dbFolder, {recursive: true}, (err) => {
+                if (err) throw err
+                resolve()
+            })
+        }).then(function () { //
+            new Promise(function (resolve, reject) {
+                // 已上传文件转存至数据库文件夹
+                fs.rename(uploadFilePath, dbFilePath, (err) => {
+                    if (err) throw err
+                    resolve(dbUrl) // 返回数据库URL
+                })
+            }).then(function (result) {
+                resolve(result)
+            })
+        })
+    })
+}
+
+// 图片删除
+function imageDelete (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.url 待删除文件的URL
+
+    return new Promise(function (resolve, reject) {
+        if (!para.url) {
+            return resolve()
+        }
+
+        fs.unlink(para.url.replace(para.pathHead.dbUrl, para.pathHead.dbFolder), (err) => {
+            if (err) throw err
+            resolve()
+        })
+    })
+}
+
+// 图片更新
+function imageUpdate (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.pathHead.uploadFolder 上传文件夹
+    // para.pathHead.uploadUrl 上传URL
+    // para.uploaded 已上传文件的URL
+    // para.old 原文件的URL
+    // para.delete 是否删除原文件
+
+    // para.dataunitId 数据单元ID
+    // para.tblName 表名
+    // para.fieldName 字段名
+    // para.fieldIndex 数组类型字段的索引
+    // para.dataId 数据ID
+
+    return new Promise(function (resolve, reject) {
+        if (!!para.uploaded || para.delete === true || para.delete === 'true') {
+            imageDelete(para.old)
+        }
+        if (!para.uploaded) {
+            return resolve(para.old)
+        }
+        imageAppend({
+            pathHead: {
+                dbFolder: para.pathHead.dbFolder,
+                dbUrl: para.pathHead.dbUrl,
+                uploadFolder: para.pathHead.uploadFolder,
+                uploadUrl: para.pathHead.uploadUrl
+            },
+            uploaded: para.uploaded,
+
+            dataunitId: para.dataunitId,
+            tblName: para.tblName,
+            fieldName: para.fieldName,
+            fieldIndex: 'fieldIndex' in para ? para.fieldIndex : 0,
+            dataId: para.dataId
+        }).then(result=>{
+            resolve(result)
+        })
+    })
+}
+
+// 图片新增 - 多文件处理
+function imagesAppend (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.pathHead.uploadFolder 上传文件夹
+    // para.pathHead.uploadUrl 上传URL
+    // para.arrUploaded 已上传文件的URL
+
+    // para.dataunitId 数据单元ID
+    // para.tblName 表名
+    // para.fieldName 字段名
+    // para.dataId 数据ID
+
+    return new Promise(function (resolve, reject) {
+        if(!para.uploaded || para.uploaded.length === 0){
+            return resolve([])
+        }
+        let arrPromise = []
+        para.arrUploaded.forEach((item, index)=>{
+            arrPromise.push(imageAppend ({
+                pathHead: {
+                    dbFolder: para.pathHead.dbFolder,
+                    dbUrl: para.pathHead.dbUrl,
+                    uploadFolder: para.pathHead.uploadFolder,
+                    uploadUrl: para.pathHead.uploadUrl
+                },
+                uploaded: item,
+
+                dataunitId: para.dataunitId,
+                tblName: para.tblName,
+                fieldName: para.fieldName,
+                fieldIndex: index,
+                dataId: para.dataId
+            }))
+        })
+        Promise.all(arrPromise).then(result=>{
+            resolve(result)
+        })
+    })
+}
+
+// 图片删除 - 多文件处理
+function imagesDelete(para){
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.arrUrl 待删除文件的URL
+
+    return new Promise(function (resolve, reject) {
+        if(!para.arrUrl || para.arrUrl.length === 0){
+            return resolve()
+        }
+
+        let arrPromise = []
+        para.arrUrl.forEach(i=>{
+            arrPromise.push(imageDelete({
+                pathHead: {
+                    dbFolder:  para.pathHead.dbFolder,
+                    dbUrl: para.pathHead.dbUrl
+                },
+                url: i
+            }))
+        })
+        Promise.all((arrPromise)).then(()=>{
+            resolve()
+        })
+    })
+}
+
+// 图片更新 - 多文件处理
+function imagesUpdate (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.pathHead.uploadFolder 上传文件夹
+    // para.pathHead.uploadUrl 上传URL
+    // para.arrUploaded 已上传文件的URL
+    // para.arrOld 原文件的URL
+    // para.arrDelete 待删除文件的URL
+
+    // para.dataunitId 数据单元ID
+    // para.tblName 表名
+    // para.fieldName 字段名
+    // para.dataId 数据ID
+
+    return new Promise(function (resolve, reject) {
+        imagesDelete({
+            pathHead: {
+                dbFolder: para.pathHead.dbFolder,
+                dbUrl: para.pathHead.dbUrl
+            },
+            arrUrl: para.arrDelete
+        }).then(()=>{
+            imagesAppend ({
+                pathHead: {
+                    dbFolder: para.pathHead.dbFolder,
+                    dbUrl: para.pathHead.dbUrl,
+                    uploadFolder: para.pathHead.uploadFolder,
+                    uploadUrl: para.pathHead.uploadUrl
+                },
+                arrUploaded: para.arrUploaded,
+
+                dataunitId: para.dataunitId,
+                tblName: para.tblName,
+                fieldName: para.fieldName,
+                dataId: para.dataId
+            }).then(result=>{
+                let arrHoldon = []
+                para.arrOld.forEach(i=>{
+                    let holdon = true
+                    para.arrDelete.forEach(j=>{
+                        if(i === j){
+                            holdon = false
+                        }
+                    })
+                    if(!!holdon){
+                        arrHoldon.push(i)
+                    }
+                })
+                resolve(arrHoldon.concat(result))
+            })
+        })
+    })
+}
+
+// 内部模块：获取富文本中资源文件(图片等)的src
+function richtextGetSrc (richtext) {
+    let arrSrc = []
+    if (richtext) {
+        arrSrc = richtext.match(/src=[\"\'][^\"\']{0,}[\"\']/g)
+        for (let i in arrSrc) {
+            let a = arrSrc [i]
+            arrSrc [i] = a.slice(5, a.length - 1)
+        }
+    }
+    return arrSrc
+}
+
+// 富文本新增
+function richtextAppend (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.pathHead.uploadFolder 上传文件夹
+    // para.pathHead.uploadUrl 上传URL
+    // para.richtext 富文本
+
+    // para.dataunitId 数据单元ID
+    // para.tblName 表名
+    // para.fieldName 字段名
+    // para.dataId 数据ID
+
+    return new Promise(function (resolve, reject) {
+        let richtextReturn = para.richtext,
+            arrSrc = richtextGetSrc(para.richtext);
+
+        let dbFolder = para.pathHead.dbFolder +
+            (para.dataunitId ? '/' + para.dataunitId : '') +
+            '/' + para.tblName +
+            '/' + para.fieldName +
+            '/' + thisTime.getFullYear() +
+            '/' + (thisTime.getMonth() + 1);
+
+        new Promise(function (resolve, reject) {
+            // 创建数据库文件夹
+            fs.mkdir(dbFolder, {recursive: true}, (err) => {
+                if (err) throw err
+                resolve()
+            })
+        }).then(function () { //上传文件转存，富文本处理
+            let arrPromise = []
+
+            for (let i in arrSrc) {
+                let uploadFilePath = arrSrc[i].replace(para.pathHead.uploadUrl, para.pathHead.uploadFolder),
+                    dbFilePath = dbFolder + '/' +
+                        (para.dataunitId ? para.dataunitId + '.' : '') +
+                        para.tblName + '.' +
+                        para.fieldName + '.' +
+                        para.dataId + '.' +
+                        Math.floor((999999 - 0) * Math.random() + 0) +
+                        path.parse(arrSrc [i]).ext,
+                    dbUrl = dbFilePath.replace(para.pathHead.dbFolder, para.pathHead.dbUrl)
+
+                arrPromise[i] = new Promise(function (resolve, reject) {
+                    // 已上传文件转存至数据库文件夹
+                    fs.rename(uploadFilePath, dbFilePath, (err) => {
+                        if (err) throw err
+
+                        // 重置富文本内的src
+                        richtextReturn = richtextReturn.replace(arrSrc[i], dbUrl)
+
+                        resolve()
+                    })
+                })
+            }
+
+            Promise.all(arrPromise).then(function () {
+                resolve(richtextReturn)
+            })
+        })
+    })
+}
+
+// 富文本删除
+function richtextDelete (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.richtext 富文本
+
+    return new Promise(function (resolve, reject) {
+        let arrSrc = richtextGetSrc(para.richtext),
+            arrPromise = []
+
+        for (let i in arrSrc) {
+            arrPromise[i] = new Promise(function (resolve, reject) {
+                fs.unlink(arrSrc [i].replace(para.pathHead.dbUrl, para.pathHead.dbFolder), err => {
+                    if (err) throw err
+                    resolve()
+                })
+            })
+        }
+
+        Promise.all(arrPromise).then(function () {
+            resolve({code: 0, message: '删除成功'})
+        })
+    })
+}
+
+// 富文本更新
+function richtextReturn (para) {
+    // para.pathHead 路径头部
+    // para.pathHead.dbFolder 数据库文件夹
+    // para.pathHead.dbUrl 数据库URL
+    // para.pathHead.uploadFolder 上传文件夹
+    // para.pathHead.uploadUrl 上传URL
+    // para.richtextNew 新富文本
+    // para.richtextOld 原富文本
+    
+    // para.dataunitId 数据单元ID
+    // para.tblName 表名
+    // para.fieldName 字段名
+    // para.dataId 数据ID
+
+    return new Promise(function (resolve, reject) {
+        let richtextReturn = para.richtextNew,
+            arrSrcNew = richtextGetSrc(para.richtextNew),
+            arrSrcOld = richtextGetSrc(para.richtextOld)
+
+        let dbFolder = para.pathHead.dbFolder + 
+            (para.dataunitId ? '/' + para.dataunitId : '') +
+            '/' + para.tblName + 
+            '/' + para.fieldName + 
+            '/' + thisTime.getFullYear() + 
+            '/' + (thisTime.getMonth() + 1)
+
+        new Promise(function (resolve, reject) {
+            // 创建数据库文件夹
+            fs.mkdir(dbFolder, {recursive: true}, (err) => {
+                if (err) console.log(err)
+                resolve()
+            })
+        }).then(function () {
+            new Promise(function (resolve, reject) {
+                let arrPromise = []
+                for (let i in arrSrcNew) {
+                    // 处理富文本 richtextNew 内的新增src
+                    if (arrSrcNew [i].startsWith(para.pathHead.uploadUrl)) {
+                        let uploadFilePath = arrSrcNew [i].replace(para.pathHead.uploadUrl, para.pathHead.uploadFolder),
+                            dbFilePath = dbFolder + '/' +
+                                (para.dataunitId ? para.dataunitId + '.' : '') +
+                                para.tblName + '.' +
+                                para.fieldName + '.' +
+                                para.dataId + '.' +
+                                Math.floor((999999 - 0) * Math.random() + 0) +
+                                path.parse(arrSrcNew [i]).ext,
+                            dbUrl = dbFilePath.replace(para.pathHead.dbFolder, para.pathHead.dbUrl)
+    
+                        arrPromise.push(new Promise(function (resolve, reject) {
+                            // 已上传文件转存至数据库文件夹
+                            fs.rename(uploadFilePath, dbFilePath, (err) => {
+                                if (err) throw err
+    
+                                // 重置富文本内新增的src
+                                richtextReturn = richtextReturn.replace(arrSrcNew [i], dbUrl)
+    
+                                resolve()
+                            })
+                        }))
+                    } else {
+                        // 处理富文本 richtextNew 内的原src，原文件保留
+                        for (let j in arrSrcOld) {
+                            if (arrSrcOld [j] === arrSrcNew [i]) {
+                                arrSrcOld [j] = ''
+                            }
+                        }
+                    }
+                }
+    
+                Promise.all(arrPromise).then(function () {
+                    resolve()
+                })
+            }).then(function () {
+                let arrPromise = []
+                for (let i in arrSrcOld) {
+                    if (arrSrcOld [i]) {
+                        arrPromise.push(new Promise(function (resolve, reject) {
+                            // 删除垃圾文件
+                            fs.unlink(arrSrcOld [i].replace(para.pathHead.dbUrl, para.pathHead.dbFolder), err => {
+                                if (err) throw err
+                                resolve()
+                            })
+                        }))
+                    }
+                }
+    
+                Promise.all(arrPromise).then(function () {
+                    resolve(richtextReturn)
+                })
+            })
+        })
+    })
+}
+
+export default {
+    imageAppend,
+    imageDelete,
+    imageUpdate,
+    imagesAppend,
+    imagesDelete,
+    imagesUpdate,
+    richtextAppend,
+    richtextDelete,
+    richtextReturn
+}

package/src/libs/multer/multer.js

@@ -0,0 +1,183 @@
+import multer from 'multer';
+import path from 'path';
+import { access, mkdir, constants } from 'fs/promises';
+
+/**
+ * 运行 Multer 中间件的辅助函数。
+ * Multer 中间件需要 (req, res, next) 参数，此函数将其封装为 Promise。
+ * @param {Function} uploadMiddleware - Multer 返回的中间件函数 (如 upload.single('file'))
+ * @param {object} req - Express 请求对象
+ * @param {object} res - Express 响应对象
+ * @returns {Promise<{request: object, response: object}>} - 包含 req/res 对象的 Promise
+ */
+function runMulterMiddleware(uploadMiddleware, req, res) {
+    return new Promise((resolve, reject) => {
+        // 执行 Multer 中间件
+        uploadMiddleware(req, res, (err) => {
+            if (err) {
+                // 如果 Multer 发生错误 (如文件类型、大小限制)，reject Promise
+                return reject(err);
+            }
+            // 成功后，req 对象中会包含 file/files 属性
+            resolve({ request: req, response: res });
+        });
+    });
+}
+
+
+/**
+ * 检查并创建目录（如果不存在）
+ * @param {string} dirPath - 目录路径
+ */
+async function ensureDirectoryExists(dirPath) {
+    try {
+        // 尝试访问目录，检查它是否存在
+        await access(dirPath, constants.F_OK);
+    } catch (error) {
+        // 如果目录不存在 (ENOENT)
+        if (error.code === 'ENOENT') {
+            console.log(`上传目录不存在，正在创建: ${dirPath}`);
+            try {
+                // 递归创建目录
+                await mkdir(dirPath, { recursive: true });
+                console.log(`目录创建成功: ${dirPath}`);
+            } catch (mkdirError) {
+                // 如果创建失败，抛出错误
+                throw new Error(`无法创建上传目录 ${dirPath}: ${mkdirError.message}`);
+            }
+        } else {
+            // 其他访问错误 (例如权限问题)
+            throw new Error(`访问目录 ${dirPath} 时发生错误: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * 初始化 Multer 配置
+ * @param {object} options
+ * @param {string} options.destination - 目标存储目录
+ * @param {number} options.fileSize - 文件大小限制
+ * @param {string[]} options.fileMimetype - 允许的文件 MimeType 列表
+ */
+async function init({destination, fileSize, fileMimetype}){
+    // 1. 确保目标目录在 Multer 初始化前就存在
+    await ensureDirectoryExists(destination);
+
+    // 2. 配置 DiskStorage
+    const storage = multer.diskStorage({
+        // destination 确定文件存储的目录
+        destination: function (req, file, cb) {
+            // 目录检查已在 init() 中提前完成，这里直接返回目标路径
+            cb(null, destination);
+        },
+        // filename 确定文件的名称
+        filename: function (req, file, cb) {
+            // 拼接原始文件名和时间戳，确保文件名的唯一性
+            const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+            // 使用 path.extname 获取文件扩展名
+            cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
+        }
+    });
+
+    // 3. 初始化 Multer 实例
+    return multer({
+        storage: storage,
+        // 文件大小限制
+        limits: { fileSize },
+        // 文件过滤
+        fileFilter: (req, file, cb) => {
+            if (fileMimetype.includes(file.mimetype)) {
+                cb(null, true); // 接受文件
+            } else {
+                // 拒绝文件，并返回一个错误 (已本地化为中文)
+                cb(new Error('文件类型无效，只允许 ' + fileMimetype.join(', ') + ' 格式！'), false);
+            }
+        }
+    })
+}
+
+/**
+ * 处理单个文件上传
+ * @param {object} request - Express 请求对象
+ * @param {object} response - Express 响应对象
+ * @param {object} options - 配置选项
+ */
+async function holdSingle(request, response, {
+    destination = 'uploads', // 项目执行的相对路径
+    fileSize = 1024 * 1024 * 1, // 默认 1MB
+    fileMimetype = [
+        'image/jpeg',
+        'image/png'
+    ],
+    fieldName = 'file' // 字段名
+}){
+    const upload = await init({destination, fileSize, fileMimetype});
+    // 获取 Multer 中间件
+    const uploadMiddleware = upload.single(fieldName);
+
+    try {
+        // 使用 Promise 运行中间件，并等待结果
+        const result = await runMulterMiddleware(uploadMiddleware, request, response);
+
+        // 成功，检查文件信息是否在请求对象中
+        if(result.request.file && result.request.file.filename){
+            return {
+                code: 0,
+                message: '上传成功',
+                file: result.request.file
+            };
+        } else {
+            // 这通常发生在未选择文件但 Multer 成功处理请求时
+            return {code: 1, message: '上传失败或未选择文件'};
+        }
+    } catch (err) {
+        // 捕获并拒绝 Multer 产生的错误 (如大小限制、文件类型错误等)
+        // 这样外部调用者就可以使用 try...catch 来捕获这些错误
+        return Promise.reject(err);
+    }
+}
+
+/**
+ * 处理多个文件上传 (数组)
+ * @param {object} request - Express 请求对象
+ * @param {object} response - Express 响应对象
+ * @param {object} options - 配置选项
+ */
+async function holdArray(request, response, {
+    destination = 'uploads',
+    fileSize = 1024 * 1024 * 1, // 默认 1MB
+    fileMimetype = [
+        'image/jpeg',
+        'image/png'
+    ],
+    fieldName = 'files',
+    maxCount = 10
+}){
+    const upload = await init({destination, fileSize, fileMimetype});
+    // 获取 Multer 中间件
+    const uploadMiddleware = upload.array(fieldName, maxCount);
+
+    try {
+        // 使用 Promise 运行中间件，并等待结果
+        const result = await runMulterMiddleware(uploadMiddleware, request, response);
+
+        // 成功，检查文件列表是否在请求对象中
+        if(result.request.files && result.request.files.length > 0){
+            return {
+                code: 0,
+                message: '上传成功',
+                files: result.request.files
+            };
+        } else {
+            return {code: 1, message: '上传失败或未选择文件'};
+        }
+    } catch (err) {
+        // 捕获并拒绝 Multer 产生的错误
+        return Promise.reject(err);
+    }
+}
+
+export default {
+    holdSingle,
+    holdArray
+}

package/src/libs/readfile/Utf8.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+
+// 异步读取
+async function readFileAsync(filePath) {
+    try {
+        const data = await fs.readFile(filePath, 'utf8');
+        return {code: 0, message: '读取文件内容成功', data}
+    } catch (err) {
+        return {code: 1, message: '读取文件内容失败', err}
+    }
+}
+
+// 同步读取
+function readFileSync(filePath){
+    try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        return {code: 0, message: '读取文件内容成功', data}
+    } catch (err) {
+        return {code: 1, message: '读取文件内容失败', err}
+    }
+}
+
+export default {
+    readFileAsync,
+    readFileSync
+}