@internxt/cli 1.2.2 → 1.3.0

package/dist/commands/move-file.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+const drive_file_service_1 = require("../services/drive/drive-file.service");
+const errors_utils_1 = require("../utils/errors.utils");
+class MoveFile extends core_1.Command {
+    static args = {};
+    static description = 'Move a file into a destination folder.';
+    static aliases = ['move:file'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The file id to be moved.',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'd',
+            description: 'The destination folder id where the file is going to be moved.',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(MoveFile);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const fileUuid = await this.getFileUuid(flags['id'], nonInteractive);
+        const destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid, destinationFolderUuid });
+        cli_utils_1.CLIUtils.success(`File moved successfully to: ${destinationFolderUuid}`);
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getFileUuid = async (fileUuidFlag, nonInteractive) => {
+        let fileUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: fileUuidFlag,
+            name: MoveFile.flags['id'].name,
+            error: new command_types_1.NotValidFileUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (fileUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(fileUuid));
+        if (!fileUuid) {
+            fileUuid = (await this.getFileUuidInteractively()).trim();
+        }
+        return fileUuid;
+    };
+    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
+        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: destinationFolderUuidFlag,
+            name: MoveFile.flags['destination'].name,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
+        if (!destinationFolderUuid) {
+            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
+        }
+        return destinationFolderUuid;
+    };
+    static MAX_ATTEMPTS = 3;
+    getFileUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the file id you want to move?',
+            options: { required: true },
+            error: new command_types_1.NotValidFileUuidError(),
+        }, MoveFile.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+    getDestinationFolderUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the destination folder id?',
+            options: { required: true },
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, MoveFile.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+}
+exports.default = MoveFile;

package/dist/commands/move-folder.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class MoveFolder extends Command {
+    static readonly args: {};
+    static readonly description = "Move a folder into a destination folder.";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+    getFolderUuid: (folderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getDestinationFolderUuid: (destinationFolderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getFolderUuidInteractively: () => Promise<string>;
+    getDestinationFolderUuidInteractively: () => Promise<string>;
+}

package/dist/commands/move-folder.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const drive_folder_service_1 = require("../services/drive/drive-folder.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+const errors_utils_1 = require("../utils/errors.utils");
+class MoveFolder extends core_1.Command {
+    static args = {};
+    static description = 'Move a folder into a destination folder.';
+    static aliases = ['move:folder'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The folder id to be moved.',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'd',
+            description: 'The destination folder id where the folder is going to be moved.',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(MoveFolder);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const folderUuid = await this.getFolderUuid(flags['id'], nonInteractive);
+        const destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid, destinationFolderUuid });
+        cli_utils_1.CLIUtils.success(`Folder moved successfully to: ${destinationFolderUuid}`);
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getFolderUuid = async (folderUuidFlag, nonInteractive) => {
+        let folderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderUuidFlag,
+            name: MoveFolder.flags['id'].name,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
+        if (!folderUuid) {
+            folderUuid = (await this.getFolderUuidInteractively()).trim();
+        }
+        return folderUuid;
+    };
+    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
+        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: destinationFolderUuidFlag,
+            name: MoveFolder.flags['destination'].name,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
+        if (!destinationFolderUuid) {
+            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
+        }
+        return destinationFolderUuid;
+    };
+    static MAX_ATTEMPTS = 3;
+    getFolderUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the folder id you want to move?',
+            options: { required: true },
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, MoveFolder.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+    getDestinationFolderUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the destination folder id?',
+            options: { required: true },
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, MoveFolder.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+}
+exports.default = MoveFolder;

package/dist/commands/rename.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Rename extends Command {
+    static readonly args: {};
+    static readonly description = "Rename a folder/file.";
+    static readonly examples: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+    getItemUuid: (itemUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getNewName: (newNameUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getItemUuidInteractively: () => Promise<string>;
+    getNewNameInteractively: () => Promise<string>;
+}

package/dist/commands/{move.js → rename.js}

@@ -8,31 +8,31 @@ const command_types_1 = require("../types/command.types");
 const validation_service_1 = require("../services/validation.service");
 const drive_file_service_1 = require("../services/drive/drive-file.service");
 const errors_utils_1 = require("../utils/errors.utils");
-class Move extends core_1.Command {
+class Rename extends core_1.Command {
     static args = {};
-    static description = 'Move a folder/file into a destination folder.';
+    static description = 'Rename a folder/file.';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
         ...cli_utils_1.CLIUtils.CommonFlags,
         id: core_1.Flags.string({
             char: 'i',
-            description: 'The item id to be moved (it can be a file id or a folder id).',
+            description: 'The ID of the item to rename (can be a file ID or a folder ID).',
             required: false,
         }),
-        destination: core_1.Flags.string({
-            char: 'd',
-            description: 'The destination folder id where the item is going to be moved.',
+        name: core_1.Flags.string({
+            char: 'n',
+            description: 'The new name for the item.',
             required: false,
         }),
     };
     async run() {
-        const { flags } = await this.parse(Move);
+        const { flags } = await this.parse(Rename);
         const nonInteractive = flags['non-interactive'];
         const userCredentials = await config_service_1.ConfigService.instance.readUser();
         if (!userCredentials)
             throw new command_types_1.MissingCredentialsError();
         const itemUuid = await this.getItemUuid(flags['id'], nonInteractive);
-        const destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        const newName = await this.getNewName(flags['name'], nonInteractive);
         let item;
         let isFolder = false;
         try {
@@ -54,12 +54,12 @@ class Move extends core_1.Command {
         if (!item)
             throw new command_types_1.ItemNotFoundError();
         if (isFolder) {
-            await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid: item.uuid, destinationFolderUuid });
+            await drive_folder_service_1.DriveFolderService.instance.renameFolder({ folderUuid: item.uuid, name: newName });
         }
         else {
-            await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid: item.uuid, destinationFolderUuid });
+            await drive_file_service_1.DriveFileService.instance.renameFile(item.uuid, { plainName: newName });
         }
-        cli_utils_1.CLIUtils.success(`${isFolder ? 'Folder' : 'File'} moved successfully to: ${destinationFolderUuid}`);
+        cli_utils_1.CLIUtils.success(`${isFolder ? 'Folder' : 'File'} renamed successfully with: ${newName}`);
     }
     async catch(error) {
         errors_utils_1.ErrorUtils.report(error, { command: this.id });
@@ -69,7 +69,7 @@ class Move extends core_1.Command {
     getItemUuid = async (itemUuidFlag, nonInteractive) => {
         let itemUuid = cli_utils_1.CLIUtils.getValueFromFlag({
             value: itemUuidFlag,
-            name: Move.flags['id'].name,
+            name: Rename.flags['id'].name,
             error: new command_types_1.NotValidItemUuidError(),
             canBeEmpty: true,
         }, nonInteractive, (itemUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(itemUuid));
@@ -78,32 +78,32 @@ class Move extends core_1.Command {
         }
         return itemUuid;
     };
-    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
-        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
-            value: destinationFolderUuidFlag,
-            name: Move.flags['destination'].name,
-            error: new command_types_1.NotValidFolderUuidError(),
+    getNewName = async (newNameUuidFlag, nonInteractive) => {
+        let newName = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: newNameUuidFlag,
+            name: Rename.flags['name'].name,
+            error: new command_types_1.EmptyItemNameError(),
             canBeEmpty: true,
-        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
-        if (!destinationFolderUuid) {
-            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
+        }, nonInteractive, (password) => password.trim().length > 0);
+        if (!newName) {
+            newName = (await this.getNewNameInteractively()).trim();
         }
-        return destinationFolderUuid;
+        return newName;
     };
     static MAX_ATTEMPTS = 3;
     getItemUuidInteractively = () => {
         return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is the item id you want to move?',
+            message: 'What is the item id you want to rename?',
             options: { required: true },
             error: new command_types_1.NotValidItemUuidError(),
-        }, Move.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+        }, Rename.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
     };
-    getDestinationFolderUuidInteractively = () => {
+    getNewNameInteractively = () => {
         return cli_utils_1.CLIUtils.promptWithAttempts({
-            message: 'What is the destination folder id?',
-            options: { required: true },
-            error: new command_types_1.NotValidFolderUuidError(),
-        }, Move.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+            message: 'What is the new name of the item?',
+            options: { required: false },
+            error: new command_types_1.EmptyItemNameError(),
+        }, Rename.MAX_ATTEMPTS, (newName) => newName.trim().length > 0);
     };
 }
-exports.default = Move;
+exports.default = Rename;

package/dist/commands/trash-clear.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class TrashClear extends Command {
+    static readonly args: {};
+    static readonly description = "Deletes permanently all the content of the trash. This action cannot be undone.";
+    static readonly examples: string[];
+    static readonly aliases: string[];
+    static readonly flags: {
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+    getConfirmation: () => Promise<string>;
+    getConfirmationInteractively: () => Promise<string>;
+}

package/dist/commands/trash-clear.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const errors_utils_1 = require("../utils/errors.utils");
+const trash_service_1 = require("../services/drive/trash.service");
+const validation_service_1 = require("../services/validation.service");
+class TrashClear extends core_1.Command {
+    static args = {};
+    static description = 'Deletes permanently all the content of the trash. This action cannot be undone.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static aliases = ['trash:clear'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        force: core_1.Flags.boolean({
+            char: 'f',
+            description: 'It forces the trash to be emptied without confirmation.',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrashClear);
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        if (!flags.force) {
+            if (flags['non-interactive']) {
+                cli_utils_1.CLIUtils.error('The "non interactive" flag is enabled, but the "force" flag has not been provided. User confirmation is required to empty the trash permanently.');
+                return;
+            }
+            const confirmation = await this.getConfirmation();
+            if (confirmation !== 'y') {
+                cli_utils_1.CLIUtils.error('User confirmation is required to empty the trash permanently.');
+                return;
+            }
+        }
+        await trash_service_1.TrashService.instance.clearTrash();
+        cli_utils_1.CLIUtils.success('Trash emptied correctly');
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getConfirmation = async () => {
+        let confirmation = (await this.getConfirmationInteractively()).trim().toLowerCase();
+        if (confirmation.length === 0) {
+            confirmation = 'no';
+        }
+        if (!validation_service_1.ValidationService.instance.validateYesOrNoString(confirmation)) {
+            throw new command_types_1.NotValidYesOrNoError();
+        }
+        return confirmation.charAt(0);
+    };
+    getConfirmationInteractively = () => {
+        return cli_utils_1.CLIUtils.prompt({
+            message: 'Empty trash? All items in the Drive Trash will be permanently deleted. This action cannot be undone. [y/N]',
+            options: { required: false },
+        });
+    };
+}
+exports.default = TrashClear;

package/dist/commands/trash-list.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+export default class TrashList extends Command {
+    static readonly args: {};
+    static readonly description = "Lists the content of the trash.";
+    static readonly examples: string[];
+    static readonly aliases: string[];
+    static readonly flags: {
+        columns: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        csv: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        filter: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'no-header': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-truncate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        sort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/trash-list.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const format_utils_1 = require("../utils/format.utils");
+const errors_utils_1 = require("../utils/errors.utils");
+const trash_service_1 = require("../services/drive/trash.service");
+class TrashList extends core_1.Command {
+    static args = {};
+    static description = 'Lists the content of the trash.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static aliases = ['trash:list'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        ...core_1.ux.table.flags(),
+    };
+    async run() {
+        const { flags } = await this.parse(TrashList);
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const { folders, files } = await trash_service_1.TrashService.instance.getTrashFolderContent();
+        const allItems = [
+            ...folders.map((folder) => {
+                return {
+                    isFolder: true,
+                    plainName: folder.plainName,
+                    uuid: folder.uuid,
+                    type: '',
+                    size: BigInt(0),
+                    updatedAt: folder.updatedAt,
+                };
+            }),
+            ...files.map((file) => {
+                return {
+                    isFolder: false,
+                    plainName: file.plainName,
+                    uuid: file.uuid,
+                    type: file.type,
+                    size: file.size,
+                    updatedAt: file.updatedAt,
+                };
+            }),
+        ];
+        core_1.ux.table(allItems, {
+            type: {
+                header: 'Type',
+                get: (row) => (row.isFolder ? 'folder' : 'file'),
+            },
+            name: {
+                header: 'Name',
+                get: (row) => (row.isFolder ? row.plainName : `${row.plainName}.${row.type}`),
+            },
+            updatedAt: {
+                header: 'Modified',
+                get: (row) => {
+                    if (flags.output) {
+                        return row.updatedAt;
+                    }
+                    else {
+                        return format_utils_1.FormatUtils.formatDate(row.updatedAt);
+                    }
+                },
+                extended: true,
+            },
+            size: {
+                header: 'Size',
+                get: (row) => {
+                    if (flags.output) {
+                        return row.isFolder ? '0' : row.size;
+                    }
+                    else {
+                        return row.isFolder ? '' : format_utils_1.FormatUtils.humanFileSize(Number(row.size));
+                    }
+                },
+                extended: true,
+            },
+            uuid: {
+                header: 'ID',
+                get: (row) => row.uuid,
+            },
+        }, {
+            printLine: this.log.bind(this),
+            ...flags,
+        });
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+}
+exports.default = TrashList;

package/dist/commands/trash-restore-file.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class TrashRestoreFile extends Command {
+    static readonly args: {};
+    static readonly description = "Restore a trashed file into a destination folder.";
+    static readonly examples: string[];
+    static readonly aliases: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+    getFileUuid: (fileUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getDestinationFolderUuid: (destinationFolderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getFileUuidInteractively: () => Promise<string>;
+    getDestinationFolderUuidInteractively: () => Promise<string>;
+}

package/dist/commands/trash-restore-file.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const config_service_1 = require("../services/config.service");
+const cli_utils_1 = require("../utils/cli.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+const drive_file_service_1 = require("../services/drive/drive-file.service");
+const errors_utils_1 = require("../utils/errors.utils");
+class TrashRestoreFile extends core_1.Command {
+    static args = {};
+    static description = 'Restore a trashed file into a destination folder.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static aliases = ['trash:restore:file'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The file id to be restored from the trash.',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'd',
+            description: 'The folder id where the file is going to be restored. Leave empty for the root folder.',
+            required: false,
+            parse: cli_utils_1.CLIUtils.parseEmpty,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrashRestoreFile);
+        const nonInteractive = flags['non-interactive'];
+        const userCredentials = await config_service_1.ConfigService.instance.readUser();
+        if (!userCredentials)
+            throw new command_types_1.MissingCredentialsError();
+        const fileUuid = await this.getFileUuid(flags['id'], nonInteractive);
+        let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        if (destinationFolderUuid.trim().length === 0) {
+            destinationFolderUuid = userCredentials.root_folder_uuid;
+        }
+        await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid, destinationFolderUuid });
+        cli_utils_1.CLIUtils.success(`File restored successfully to: ${destinationFolderUuid}`);
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    getFileUuid = async (fileUuidFlag, nonInteractive) => {
+        let fileUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: fileUuidFlag,
+            name: TrashRestoreFile.flags['id'].name,
+            error: new command_types_1.NotValidFileUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (fileUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(fileUuid));
+        if (!fileUuid) {
+            fileUuid = (await this.getFileUuidInteractively()).trim();
+        }
+        return fileUuid;
+    };
+    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
+        let destinationFolderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: destinationFolderUuidFlag,
+            name: TrashRestoreFile.flags['destination'].name,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, nonInteractive, (folderUuid) => validation_service_1.ValidationService.instance.validateUUIDv4(folderUuid));
+        if (!destinationFolderUuid) {
+            destinationFolderUuid = (await this.getDestinationFolderUuidInteractively()).trim();
+        }
+        return destinationFolderUuid;
+    };
+    static MAX_ATTEMPTS = 3;
+    getFileUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the file id you want to restore?',
+            options: { required: true },
+            error: new command_types_1.NotValidFileUuidError(),
+        }, TrashRestoreFile.MAX_ATTEMPTS, validation_service_1.ValidationService.instance.validateUUIDv4);
+    };
+    getDestinationFolderUuidInteractively = () => {
+        return cli_utils_1.CLIUtils.prompt({
+            message: 'What is the destination folder id? (leave empty for the root folder)',
+            options: { required: false },
+        });
+    };
+}
+exports.default = TrashRestoreFile;

package/dist/commands/trash-restore-folder.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class TrashRestoreFolder extends Command {
+    static readonly args: {};
+    static readonly description = "Restore a trashed folder into a destination folder.";
+    static readonly examples: string[];
+    static readonly aliases: string[];
+    static readonly flags: {
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+    getFolderUuid: (folderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getDestinationFolderUuid: (destinationFolderUuidFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    private static readonly MAX_ATTEMPTS;
+    getFolderUuidInteractively: () => Promise<string>;
+    getDestinationFolderUuidInteractively: () => Promise<string>;
+}