@kne/fastify-file-manager 1.1.2 → 1.2.0

package/index.js

@@ -1,6 +1,7 @@
 const fp = require('fastify-plugin');
 const path = require('path');
 const fs = require('fs-extra');
+const packageJson = require('./package.json');
 
 module.exports = fp(
   async (fastify, options) => {
@@ -8,13 +9,16 @@ module.exports = fp(
       {
         root: path.join(process.cwd(), 'static'),
         namespace: 'default',
-        prefix: '/api/static',
+        prefix: `/api/v${packageJson.version.split('.')[0]}/static`,
         dbTableNamePrefix: 't_file_manager_',
         multipart: {},
         static: {},
-        authenticateFileRead: async () => {},
-        authenticateFileMange: async () => {},
-        authenticateFileUpload: async () => {}
+        ossAdapter: () => {
+          return {};
+        },
+        createAuthenticate: () => {
+          return [];
+        }
       },
       options
     );

package/libs/controllers/index.js

@@ -5,7 +5,15 @@ module.exports = fp(async (fastify, options) => {
   fastify.post(
     `${options.prefix}/upload`,
     {
-      onRequest: [options.authenticateFileUpload]
+      onRequest: options.createAuthenticate('file:write'),
+      schema: {
+        query: {
+          type: 'object',
+          properties: {
+            namespace: { type: 'string' }
+          }
+        }
+      }
     },
     async request => {
       const file = await request.file();
@@ -13,14 +21,17 @@ module.exports = fp(async (fastify, options) => {
         throw new Error('不能获取到上传文件');
       }
       //1. 保存到服务器目录 2.对接oss
-      return await services.fileRecord.uploadToFileSystem({ file, namespace: options.namespace });
+      return await services.fileRecord.uploadToFileSystem({
+        file,
+        namespace: request.query.namespace || options.namespace
+      });
     }
   );
 
   fastify.get(
     `${options.prefix}/file-url/:id`,
     {
-      onRequest: [options.authenticateFileRead],
+      onRequest: options.createAuthenticate('file:read'),
       schema: {
         params: {
           type: 'object',
@@ -33,14 +44,14 @@ module.exports = fp(async (fastify, options) => {
     },
     async request => {
       const { id } = request.params;
-      return await services.fileRecord.getFileUrl({ id, namespace: options.namespace });
+      return await services.fileRecord.getFileUrl({ id });
     }
   );
 
   fastify.get(
     `${options.prefix}/file-id/:id`,
     {
-      onRequest: [options.authenticateFileRead],
+      onRequest: options.createAuthenticate('file:read'),
       schema: {
         query: {
           type: 'object',
@@ -61,58 +72,116 @@ module.exports = fp(async (fastify, options) => {
     async (request, reply) => {
       const { id } = request.params;
       const { attachment, filename: targetFilename } = request.query;
-      const { targetFileName, filename } = await services.fileRecord.getFileInfo({
-        id,
-        namespace: options.namespace
+      const { filePath, targetFile, filename, mimetype, ...props } = await services.fileRecord.getFileInfo({
+        id
       });
-      return attachment ? reply.download(targetFileName, targetFilename || filename) : reply.sendFile(targetFileName);
+      if (targetFile) {
+        const outputFilename = encodeURIComponent(targetFilename || filename);
+        reply.header('Content-Type', mimetype);
+        reply.header('Content-Disposition', attachment ? `attachment; filename="${outputFilename}"` : `filename="${outputFilename}"`);
+        return reply.send(targetFile);
+      }
+      return attachment ? reply.download(filePath, targetFilename || filename) : reply.sendFile(filePath);
     }
   );
 
-  fastify.get(
+  fastify.post(
     `${options.prefix}/file-list`,
     {
-      onRequest: [options.authenticateFileMange],
+      onRequest: options.createAuthenticate('file:mange'),
       schema: {
-        query: {}
+        body: {
+          type: 'object',
+          properties: {
+            perPage: { type: 'number' },
+            currentPage: { type: 'number' },
+            filter: {
+              type: 'object',
+              properties: {
+                namespace: { type: 'string' },
+                size: { type: 'array', items: { type: 'number' } },
+                filename: { type: 'string' }
+              }
+            }
+          }
+        }
       }
     },
     async request => {
-      const { filter, perPage, currentPage } = Object.assign({}, request.query, {
-        perPage: 20,
-        currentPage: 1
-      });
+      const { filter, perPage, currentPage } = Object.assign(
+        {},
+        {
+          perPage: 20,
+          currentPage: 1
+        },
+        request.body
+      );
       return await services.fileRecord.getFileList({
         filter,
-        namespace: options.namespace,
         perPage,
         currentPage
       });
     }
   );
 
+  // Replace file
+
   fastify.post(
-    `${options.prefix}/delete-file`,
+    `${options.prefix}/replace-file`,
     {
-      onRequest: [options.authenticateFileMange],
+      onRequest: options.createAuthenticate('file:mange'),
+      schema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' }
+        }
+      }
+    },
+    async request => {
+      const file = await request.file();
+      if (!file) {
+        throw new Error('不能获取到上传文件');
+      }
+      return await services.fileRecord.uploadToFileSystem({ id: request.query.id, file });
+    }
+  );
+
+  fastify.post(
+    `${options.prefix}/rename-file`,
+    {
+      onRequest: options.createAuthenticate('file:mange'),
+      schema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          filename: { type: 'string' }
+        }
+      }
+    },
+    async request => {
+      await services.fileRecord.renameFile(request.body);
+      return {};
+    }
+  );
+
+  fastify.post(
+    `${options.prefix}/delete-files`,
+    {
+      onRequest: options.createAuthenticate('file:mange'),
       schema: {
         body: {
           type: 'object',
-          required: ['id'],
+          required: ['ids'],
           properties: {
-            id: { type: 'string' }
+            ids: { type: 'array', items: { type: 'string' } }
           }
         }
       }
     },
     async request => {
-      const { id } = request.body;
-      await services.fileRecord.deleteFile({ id, namespace: options.namespace });
+      const { ids } = request.body;
+      await services.fileRecord.deleteFiles({ ids });
       return {};
     }
   );
-
-  fastify.get(`${options.prefix}`, async () => {
-    return 'living';
-  });
 });

package/libs/models/file-record.js

@@ -22,7 +22,12 @@ module.exports = ({ DataTypes }) => {
         allowNull: false
       },
       encoding: DataTypes.STRING,
-      mimetype: DataTypes.STRING
+      mimetype: DataTypes.STRING,
+      storageType: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '存储类型:local本地文件系统,oss远程oss存储'
+      }
     },
     options: {
       indexes: [

package/libs/services/file-record.js

@@ -2,59 +2,135 @@ const fp = require('fastify-plugin');
 const fs = require('fs-extra');
 const crypto = require('crypto');
 const path = require('path');
+const { NotFound } = require('http-errors');
 
 module.exports = fp(async (fastify, options) => {
   const { models, services } = fastify.fileManager;
-  const uploadToFileSystem = async ({ file, namespace }) => {
+  const { Op } = fastify.sequelize.Sequelize;
+  const uploadToFileSystem = async ({ id, file, namespace }) => {
     const { filename, encoding, mimetype } = file;
     const buffer = await file.toBuffer();
     const hash = crypto.createHash('md5');
     hash.update(buffer);
     const digest = hash.digest('hex');
     const extension = path.extname(filename);
-    const filepath = path.resolve(options.root, `${digest}${extension}`);
-    await fs.writeFile(filepath, buffer);
-    const outputFile = await models.fileRecord.create({
-      filename,
-      namespace: namespace || options.namespace,
-      encoding,
-      mimetype,
-      hash: digest,
-      size: buffer.byteLength
-    });
+
+    let storageType;
+    const ossServices = options.ossAdapter();
+    if (typeof ossServices.uploadFile === 'function') {
+      await ossServices.uploadFile({ file: buffer, filename: `${digest}${extension}` });
+      storageType = 'oss';
+    } else {
+      const filepath = path.resolve(options.root, `${digest}${extension}`);
+      await fs.writeFile(filepath, buffer);
+      storageType = 'local';
+    }
+
+    const outputFile = await (async create => {
+      if (!id) {
+        return await create();
+      }
+      const file = await models.fileRecord.findOne({ where: { uuid: id } });
+      if (!file) {
+        throw new Error('原文件不存在');
+      }
+      file.filename = filename;
+      file.encoding = encoding;
+      file.mimetype = mimetype;
+      file.hash = digest;
+      file.size = buffer.byteLength;
+      file.storageType = storageType;
+      await file.save();
+      return file;
+    })(() =>
+      models.fileRecord.create({
+        filename,
+        namespace: namespace || options.namespace,
+        encoding,
+        mimetype,
+        hash: digest,
+        size: buffer.byteLength,
+        storageType
+      })
+    );
     return Object.assign({}, outputFile.get({ plain: true }), { id: outputFile.uuid });
   };
 
   const getFileUrl = async ({ id, namespace }) => {
     const file = await models.fileRecord.findOne({
-      where: { uuid: id, namespace: namespace || options.namespace }
+      where: { uuid: id }
     });
     if (!file) {
       throw new Error('文件不存在');
     }
     const extension = path.extname(file.filename);
-    return `${options.prefix}/file/${file.hash}${extension}?filename=${file.filename}`;
+    const ossServices = options.ossAdapter();
+    if (file.storageType === 'oss' && typeof ossServices.getFileLink !== 'function') {
+      throw new Error('ossAdapter未正确配置无法读取oss类型存储文件');
+    }
+    if (file.storageType === 'oss') {
+      return await ossServices.getFileLink({ filename: `${file.hash}${extension}` });
+    }
+
+    const localPath = `${options.prefix}/file/${file.hash}${extension}?filename=${file.filename}`;
+
+    if (!(await fs.exists(localPath))) {
+      throw new NotFound();
+    }
+    return localPath;
   };
 
-  const getFileInfo = async ({ id, namespace }) => {
+  const getFileInfo = async ({ id }) => {
     const file = await models.fileRecord.findOne({
-      where: { uuid: id, namespace: namespace || options.namespace }
+      where: { uuid: id }
     });
     if (!file) {
       throw new Error('文件不存在');
     }
     const extension = path.extname(file.filename);
-    return Object.assign({}, file, {
+    const targetFileName = `${file.hash}${extension}`;
+    const ossServices = options.ossAdapter();
+    if (file.storageType === 'oss' && typeof ossServices.downloadFile !== 'function') {
+      throw new Error('ossAdapter未正确配置无法读取oss类型存储文件');
+    }
+    let targetFile;
+    if (file.storageType === 'oss') {
+      targetFile = await ossServices.downloadFile({ filename: targetFileName });
+    }
+    return Object.assign({}, file.get({ pain: true }), {
       id: file.uuid,
-      targetFileName: `${file.hash}${extension}`
+      filePath: targetFileName,
+      targetFile
     });
   };
 
-  const getFileList = async ({ filter, namespace, currentPage, perPage }) => {
-    const queryFilter = { namespace: namespace || options.namespace };
+  const getFileList = async ({ filter, currentPage, perPage }) => {
+    // namespace: namespace || options.namespace
+    const queryFilter = {};
+
+    if (filter?.filename) {
+      queryFilter.filename = {
+        [Op.like]: `%${filter.filename}%`
+      };
+    }
+    if (filter?.size && filter.size.length > 0) {
+      queryFilter.size = {};
+      if (filter.size[0]) {
+        queryFilter.size[Op.gt] = filter.size[0] * 1024;
+      }
+      if (filter.size[1]) {
+        queryFilter.size[Op.lt] = filter.size[1] * 1024;
+      }
+    }
+    if (filter?.namespace) {
+      queryFilter.namespace = {
+        [Op.like]: `%${filter.namespace}%`
+      };
+    }
+
     const { count, rows } = await models.fileRecord.findAndCountAll({
       where: queryFilter,
-      offset: currentPage * (currentPage - 1),
+      offset: perPage * (currentPage - 1),
       limit: perPage
     });
     return {
@@ -63,15 +139,26 @@ module.exports = fp(async (fastify, options) => {
     };
   };
 
-  const deleteFile = async ({ id, namespace }) => {
+  const deleteFiles = async ({ ids }) => {
+    await models.fileRecord.destroy({
+      where: {
+        uuid: {
+          [Op.in]: ids
+        }
+      }
+    });
+  };
+
+  const renameFile = async ({ id, filename }) => {
     const file = await models.fileRecord.findOne({
-      where: { uuid: id, namespace: namespace || options.namespace }
+      where: { uuid: id }
     });
     if (!file) {
       throw new Error('文件不存在');
     }
-
-    await file.destroy();
+    file.filename = filename;
+    await file.save();
   };
-  services.fileRecord = { uploadToFileSystem, getFileUrl, getFileInfo, getFileList, deleteFile };
+
+  services.fileRecord = { uploadToFileSystem, getFileUrl, getFileInfo, getFileList, deleteFiles, renameFile };
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kne/fastify-file-manager",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "用于管理静态文件上传查看等",
   "main": "index.js",
   "scripts": {
@@ -32,10 +32,13 @@
   },
   "homepage": "https://github.com/kne-union/fastify-file-manager#readme",
   "devDependencies": {
+    "@fastify/env": "^4.4.0",
+    "@kne/fastify-aliyun": "^1.1.1",
     "@kne/fastify-sequelize": "^2.0.1",
     "fastify": "^4.27.0",
     "husky": "^9.0.11",
     "prettier": "^3.2.5",
+    "qs": "^6.12.3",
     "sqlite3": "^5.1.7"
   },
   "dependencies": {
@@ -43,6 +46,7 @@
     "@fastify/static": "^7.0.4",
     "@kne/fastify-namespace": "^0.1.0",
     "fastify-plugin": "^4.5.1",
-    "fs-extra": "^11.2.0"
+    "fs-extra": "^11.2.0",
+    "http-errors": "^2.0.0"
   }
 }