Finish upload folder +tests(WIP)

Author: AlexisMora

src/commands/upload-folder.ts

@@ -3,6 +3,7 @@ import { CLIUtils } from '../utils/cli.utils';
 import { AuthService } from '../services/auth.service';
 import { UploadService } from '../services/network/upload/upload.service';
 import { ValidationService } from '../services/validation.service';
+import { ConfigService } from '../services/config.service';
 
 export default class UploadFolder extends Command {
   static readonly args = {};
@@ -32,8 +33,45 @@ export default class UploadFolder extends Command {
     if (!doesDirectoryExist) {
       throw new Error(`The provided folder path is not a valid directory: ${flags['folder']}`);
     }
-    throw new Error('Not implemented yet');
-    //return await UploadService.instance.uploadFolder();
+
+    // If destinationFolderUuid is empty from flags&prompt, means we should use RootFolderUuid
+    const destinationFolderUuid =
+      (await CLIUtils.getDestinationFolderUuid({
+        destinationFolderUuidFlag: flags['destination'],
+        destinationFlagName: UploadFolder.flags['destination'].name,
+        nonInteractive: flags['non-interactive'],
+        reporter: this.log.bind(this),
+      })) ?? user.rootFolderId;
+
+    const progressBar = CLIUtils.progress(
+      {
+        format: 'Uploading folder [{bar}] {percentage}%',
+        linewrap: true,
+      },
+      flags['json'],
+    );
+    progressBar?.start(100, 0);
+    const { data, error } = await UploadService.instance.uploadFolderHandler({
+      localPath: flags['folder'],
+      destinationFolderUuid,
+      loginUserDetails: user,
+      jsonFlag: flags['json'],
+      onProgress: (progress) => {
+        progressBar?.update(progress.percentage);
+      },
+    });
+
+    progressBar?.update(100);
+    progressBar?.stop();
+
+    if (error) {
+      throw error;
+    }
+
+    const driveUrl = ConfigService.instance.get('DRIVE_WEB_URL');
+    const folderUrl = `${driveUrl}/folder/${data.rootFolderId}`;
+    const message = `Folder uploaded in ${data.uploadTimeMs}ms, view it at ${folderUrl} (${data.totalBytes} bytes)`;
+    CLIUtils.success(this.log.bind(this), message);
   };
 
   public catch = async (error: Error) => {

src/services/local-filesystem/local-filesystem.service.ts

@@ -0,0 +1,67 @@
+import { promises } from 'fs';
+import { basename, dirname, join, relative, parse } from 'path';
+import { FileSystemNode, ScanResult } from './local-filesystem.types';
+import { logger } from '../../utils/logger.utils';
+
+export class LocalFilesystemService {
+  static readonly instance = new LocalFilesystemService();
+
+  async scanLocalDirectory(path: string): Promise<ScanResult> {
+    const folders: FileSystemNode[] = [];
+    const files: FileSystemNode[] = [];
+
+    const parentPath = dirname(path);
+    const totalBytes = await this.scanRecursive(path, parentPath, folders, files);
+    return {
+      folders,
+      files,
+      totalItems: folders.length + files.length,
+      totalBytes,
+    };
+  }
+  async scanRecursive(
+    currentPath: string,
+    parentPath: string,
+    folders: FileSystemNode[],
+    files: FileSystemNode[],
+  ): Promise<number> {
+    try {
+      const stats = await promises.stat(currentPath);
+      const relativePath = relative(parentPath, currentPath);
+
+      if (stats.isFile()) {
+        const fileInfo = parse(currentPath);
+        files.push({
+          type: 'file',
+          name: fileInfo.name,
+          absolutePath: currentPath,
+          relativePath,
+          size: stats.size,
+        });
+        return stats.size;
+      }
+
+      if (stats.isDirectory()) {
+        folders.push({
+          type: 'folder',
+          name: basename(currentPath),
+          absolutePath: currentPath,
+          relativePath,
+          size: 0,
+        });
+        const entries = await promises.readdir(currentPath, { withFileTypes: true });
+        const validEntries = entries.filter((e) => !e.isSymbolicLink());
+        const bytesArray = await Promise.all(
+          validEntries.map((e) => this.scanRecursive(join(currentPath, e.name), parentPath, folders, files)),
+        );
+
+        return bytesArray.reduce((sum, bytes) => sum + bytes, 0);
+      }
+
+      return 0;
+    } catch (error: unknown) {
+      logger.warn(`Error scanning path ${currentPath}: ${(error as Error).message} - skipping...`);
+      return 0;
+    }
+  }
+}

src/services/local-filesystem/local-filesystem.types.ts

@@ -0,0 +1,14 @@
+export interface FileSystemNode {
+  type: 'file' | 'folder';
+  name: string;
+  size: number;
+  absolutePath: string;
+  relativePath: string;
+}
+
+export interface ScanResult {
+  folders: FileSystemNode[];
+  files: FileSystemNode[];
+  totalItems: number;
+  totalBytes: number;
+}