feat: Version 2

Closes #627, closes #1047

server/api/hooks/file-manager/LocalFileManager.js

@@ -1,3 +1,8 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
 const fs = require('fs');
 const fse = require('fs-extra');
 const path = require('path');
@@ -27,21 +32,80 @@ class LocalFileManager {
   }
 
   // eslint-disable-next-line class-methods-use-this
-  read(filePathSegment) {
+  async read(filePathSegment) {
     const filePath = buildPath(filePathSegment);
+    const isFileExists = await fse.pathExists(filePath);
 
-    if (!fs.existsSync(filePath)) {
+    if (!isFileExists) {
       throw new Error('File does not exist');
     }
 
     return fs.createReadStream(filePath);
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  async getSizeInBytes(filePathSegment) {
+    let result;
+    try {
+      result = await fs.promises.stat(buildPath(filePathSegment));
+    } catch (error) {
+      return null;
+    }
+
+    return result.size;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async rename(filePathSegment, nextFilePathSegment) {
+    try {
+      await fs.promises.rename(buildPath(filePathSegment), buildPath(nextFilePathSegment));
+    } catch (error) {
+      /* empty */
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async delete(filePathSegment) {
+    try {
+      await fs.promises.unlink(buildPath(filePathSegment));
+    } catch (error) {
+      /* empty */
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async listDir(dirPathSegment) {
+    let dirents;
+    try {
+      dirents = await fs.promises.readdir(buildPath(dirPathSegment), {
+        withFileTypes: true,
+      });
+    } catch (error) {
+      return null;
+    }
+
+    return dirents.flatMap((dirent) => (dirent.isDirectory() ? dirent.name : []));
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async renameDir(dirPathSegment, nextDirPathSegment) {
+    try {
+      await fs.promises.rename(buildPath(dirPathSegment), buildPath(nextDirPathSegment));
+    } catch (error) {
+      /* empty */
+    }
+  }
+
   // eslint-disable-next-line class-methods-use-this
   async deleteDir(dirPathSegment) {
     await rimraf(buildPath(dirPathSegment));
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  async isExists(pathSegment) {
+    return fse.pathExists(buildPath(pathSegment));
+  }
+
   // eslint-disable-next-line class-methods-use-this
   buildUrl(filePathSegment) {
     return `${sails.config.custom.baseUrl}/${filePathSegment.replace(PATH_SEGMENT_TO_URL_REPLACE_REGEX, '')}`;

server/api/hooks/file-manager/S3FileManager.js

@@ -1,7 +1,15 @@
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
+
 const fs = require('fs');
 const {
+  CopyObjectCommand,
   DeleteObjectsCommand,
+  DeleteObjectCommand,
   GetObjectCommand,
+  HeadObjectCommand,
   ListObjectsV2Command,
   PutObjectCommand,
 } = require('@aws-sdk/client-s3');
@@ -20,7 +28,6 @@ class S3FileManager {
     });
 
     await this.client.send(command);
-
     return null;
   }
 
@@ -45,26 +52,144 @@ class S3FileManager {
     return result.Body;
   }
 
-  async deleteDir(dirPathSegment) {
+  async getSizeInBytes(filePathSegment) {
+    const headObjectCommand = new HeadObjectCommand({
+      Bucket: sails.config.custom.s3Bucket,
+      Key: filePathSegment,
+    });
+
+    let result;
+    try {
+      result = await this.client.send(headObjectCommand);
+    } catch (error) {
+      return null;
+    }
+
+    return result.ContentLength;
+  }
+
+  async rename(filePathSegment, nextFilePathSegment) {
+    const copyObjectCommand = new CopyObjectCommand({
+      Bucket: sails.config.custom.s3Bucket,
+      Key: nextFilePathSegment,
+      CopySource: `${sails.config.custom.s3Bucket}/${filePathSegment}`,
+    });
+
+    try {
+      await this.client.send(copyObjectCommand);
+    } catch (error) {
+      return;
+    }
+
+    await this.delete(filePathSegment);
+  }
+
+  async delete(filePathSegment) {
+    const deleteObjectCommand = new DeleteObjectCommand({
+      Bucket: sails.config.custom.s3Bucket,
+      Key: filePathSegment,
+    });
+
+    await this.client.send(deleteObjectCommand);
+  }
+
+  async listDir(dirPathSegment, { ContinuationToken } = {}) {
     const listObjectsCommand = new ListObjectsV2Command({
+      ContinuationToken,
+      Bucket: sails.config.custom.s3Bucket,
+      Prefix: `${dirPathSegment}/`,
+      Delimiter: '/',
+    });
+
+    const result = await this.client.send(listObjectsCommand);
+
+    if (!result.CommonPrefixes) {
+      return null;
+    }
+
+    const dirnames = result.CommonPrefixes.map(({ Prefix }) =>
+      Prefix.slice(dirPathSegment.length + 1, -1),
+    );
+
+    if (result.IsTruncated) {
+      const otherDirnames = await this.listDir(dirPathSegment, {
+        ContinuationToken: result.NextContinuationToken,
+      });
+
+      if (otherDirnames) {
+        dirnames.push(...otherDirnames);
+      }
+    }
+
+    return dirnames;
+  }
+
+  async renameDir(dirPathSegment, nextDirPathSegment, { ContinuationToken } = {}) {
+    const listObjectsCommand = new ListObjectsV2Command({
+      ContinuationToken,
       Bucket: sails.config.custom.s3Bucket,
       Prefix: dirPathSegment,
     });
 
     const result = await this.client.send(listObjectsCommand);
 
-    if (!result.Contents || result.Contents.length === 0) {
+    if (!result.Contents) {
       return;
     }
 
-    const deleteObjectsCommand = new DeleteObjectsCommand({
+    // eslint-disable-next-line no-restricted-syntax
+    for (const { Key } of result.Contents) {
+      // eslint-disable-next-line no-await-in-loop
+      await this.rename(Key, `${nextDirPathSegment}/${Key.substring(dirPathSegment.length + 1)}`);
+    }
+
+    if (result.IsTruncated) {
+      await this.renameDir(dirPathSegment, nextDirPathSegment, {
+        ContinuationToken: result.NextContinuationToken,
+      });
+    }
+  }
+
+  async deleteDir(dirPathSegment, { ContinuationToken } = {}) {
+    const listObjectsCommand = new ListObjectsV2Command({
+      ContinuationToken,
       Bucket: sails.config.custom.s3Bucket,
-      Delete: {
-        Objects: result.Contents.map(({ Key }) => ({ Key })),
-      },
+      Prefix: dirPathSegment,
     });
 
-    await this.client.send(deleteObjectsCommand);
+    const result = await this.client.send(listObjectsCommand);
+
+    if (!result.Contents) {
+      return;
+    }
+
+    if (result.Contents.length > 0) {
+      const deleteObjectsCommand = new DeleteObjectsCommand({
+        Bucket: sails.config.custom.s3Bucket,
+        Delete: {
+          Objects: result.Contents.map(({ Key }) => ({ Key })),
+        },
+      });
+
+      await this.client.send(deleteObjectsCommand);
+    }
+
+    if (result.IsTruncated) {
+      await this.deleteDir(dirPathSegment, {
+        ContinuationToken: result.NextContinuationToken,
+      });
+    }
+  }
+
+  async isExists(pathSegment) {
+    const listObjectsCommand = new ListObjectsV2Command({
+      Bucket: sails.config.custom.s3Bucket,
+      Prefix: pathSegment,
+      MaxKeys: 1,
+    });
+
+    const result = await this.client.send(listObjectsCommand);
+    return !!result.Contents && result.Contents.length === 1;
   }
 
   // eslint-disable-next-line class-methods-use-this

server/api/hooks/file-manager/index.js

@@ -1,5 +1,7 @@
-const LocalFileManager = require('./LocalFileManager');
-const S3FileManager = require('./S3FileManager');
+/*!
+ * Copyright (c) 2024 PLANKA Software GmbH
+ * Licensed under the Fair Use License: https://github.com/plankanban/planka/blob/master/LICENSE.md
+ */
 
 /**
  * file-manager hook
@@ -9,11 +11,14 @@ const S3FileManager = require('./S3FileManager');
  * @docs        :: https://sailsjs.com/docs/concepts/extending-sails/hooks
  */
 
+const LocalFileManager = require('./LocalFileManager');
+const S3FileManager = require('./S3FileManager');
+
 module.exports = function defineFileManagerHook(sails) {
   let instance = null;
 
   const createInstance = () => {
-    instance = sails.hooks.s3.isActive()
+    instance = sails.hooks.s3.isEnabled()
       ? new S3FileManager(sails.hooks.s3.getClient())
       : new LocalFileManager();
   };