@internxt/cli 1.2.1 → 1.3.0

package/dist/commands/trash-restore-folder.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 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 TrashRestoreFolder extends core_1.Command {
+    static args = {};
+    static description = 'Restore a trashed folder into a destination folder.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static aliases = ['trash:restore:folder'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        id: core_1.Flags.string({
+            char: 'i',
+            description: 'The folder id to be restored from the trash.',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'd',
+            description: 'The folder id where the folder 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(TrashRestoreFolder);
+        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);
+        let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
+        if (destinationFolderUuid.trim().length === 0) {
+            destinationFolderUuid = userCredentials.root_folder_uuid;
+        }
+        await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid, destinationFolderUuid });
+        cli_utils_1.CLIUtils.success(`Folder 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);
+    }
+    getFolderUuid = async (folderUuidFlag, nonInteractive) => {
+        let folderUuid = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderUuidFlag,
+            name: TrashRestoreFolder.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: TrashRestoreFolder.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 restore?',
+            options: { required: true },
+            error: new command_types_1.NotValidFolderUuidError(),
+        }, TrashRestoreFolder.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 = TrashRestoreFolder;

package/dist/commands/webdav-config.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class WebDAVConfig extends Command {
+    static readonly description = "Edit the configuration of the Internxt CLI WebDav server as the port or the protocol.";
+    static readonly args: {
+        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static readonly examples: string[];
+    static readonly flags: {
+        port: 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>;
+    private static readonly MAX_ATTEMPTS;
+    getWebDAVPort: (webdavPortFlag: string | undefined, nonInteractive: boolean) => Promise<string>;
+    getNewWebDAVPortInteractively: () => Promise<string>;
+}

package/dist/commands/webdav-config.js

@@ -0,0 +1,91 @@
+"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 errors_utils_1 = require("../utils/errors.utils");
+const command_types_1 = require("../types/command.types");
+const validation_service_1 = require("../services/validation.service");
+class WebDAVConfig extends core_1.Command {
+    static description = 'Edit the configuration of the Internxt CLI WebDav server as the port or the protocol.';
+    static args = {
+        action: core_1.Args.string({
+            required: true,
+            options: ['set-http', 'set-https', 'change-port'],
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> <%= command.id %> set-http',
+        '<%= config.bin %> <%= command.id %> set-https',
+        '<%= config.bin %> <%= command.id %> change-port',
+    ];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        port: core_1.Flags.string({
+            char: 'p',
+            description: 'The new port that the WebDAV server is going to be have.',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebDAVConfig);
+        const nonInteractive = flags['non-interactive'];
+        const webdavConfig = await config_service_1.ConfigService.instance.readWebdavConfig();
+        if (args.action !== 'change-port' && flags['port']) {
+            cli_utils_1.CLIUtils.warning('The port flag will be ignored; it can only be used with the "change-port" action.');
+        }
+        switch (args.action) {
+            case 'set-http': {
+                await config_service_1.ConfigService.instance.saveWebdavConfig({
+                    ...webdavConfig,
+                    protocol: 'http',
+                });
+                cli_utils_1.CLIUtils.success('On the next start, the WebDAV server will use HTTP.');
+                break;
+            }
+            case 'set-https': {
+                await config_service_1.ConfigService.instance.saveWebdavConfig({
+                    ...webdavConfig,
+                    protocol: 'https',
+                });
+                cli_utils_1.CLIUtils.success('On the next start, the WebDAV server will use HTTPS.');
+                break;
+            }
+            case 'change-port': {
+                const newPort = await this.getWebDAVPort(flags['port'], nonInteractive);
+                await config_service_1.ConfigService.instance.saveWebdavConfig({
+                    ...webdavConfig,
+                    port: newPort,
+                });
+                cli_utils_1.CLIUtils.success('For the next start, the Webdav server will be served at the new port: ' + newPort);
+                break;
+            }
+        }
+    }
+    async catch(error) {
+        errors_utils_1.ErrorUtils.report(error, { command: this.id });
+        cli_utils_1.CLIUtils.error(error.message);
+        this.exit(1);
+    }
+    static MAX_ATTEMPTS = 3;
+    getWebDAVPort = async (webdavPortFlag, nonInteractive) => {
+        let port = cli_utils_1.CLIUtils.getValueFromFlag({
+            value: webdavPortFlag,
+            name: WebDAVConfig.flags['port'].name,
+            error: new command_types_1.NotValidPortError(),
+            canBeEmpty: true,
+        }, nonInteractive, (port) => validation_service_1.ValidationService.instance.validateTCPIntegerPort(port));
+        if (!port) {
+            port = (await this.getNewWebDAVPortInteractively()).trim();
+        }
+        return port;
+    };
+    getNewWebDAVPortInteractively = () => {
+        return cli_utils_1.CLIUtils.promptWithAttempts({
+            message: 'What is the new WebDAV server port?',
+            options: { required: false },
+            error: new command_types_1.NotValidPortError(),
+        }, WebDAVConfig.MAX_ATTEMPTS, (port) => validation_service_1.ValidationService.instance.validateTCPIntegerPort(port));
+    };
+}
+exports.default = WebDAVConfig;

package/dist/commands/webdav.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
 export default class Webdav extends Command {
-    static readonly description = "Enable,disable, restart or get the status of the Internxt CLI WebDav server";
+    static readonly description = "Enable, disable, restart or get the status of the Internxt CLI WebDav server";
     static examples: string[];
     static flags: {};
     static args: {

package/dist/commands/webdav.js

@@ -8,7 +8,7 @@ const analytics_service_1 = require("../services/analytics.service");
 const auth_service_1 = require("../services/auth.service");
 const drive_database_manager_service_1 = require("../services/database/drive-database-manager.service");
 class Webdav extends core_1.Command {
-    static description = 'Enable,disable, restart or get the status of the Internxt CLI WebDav server';
+    static description = 'Enable, disable, restart or get the status of the Internxt CLI WebDav server';
     static examples = [
         '<%= config.bin %> <%= command.id %> enable',
         '<%= config.bin %> <%= command.id %> disable',
@@ -24,14 +24,17 @@ class Webdav extends core_1.Command {
     };
     async enableWebDav() {
         cli_utils_1.CLIUtils.doing('Starting Internxt WebDav server...');
+        await drive_database_manager_service_1.DriveDatabaseManager.clean();
         await pm2_utils_1.PM2Utils.connect();
         await pm2_utils_1.PM2Utils.killWebDavServer();
         await pm2_utils_1.PM2Utils.startWebDavServer();
         cli_utils_1.CLIUtils.done();
         const { status } = await pm2_utils_1.PM2Utils.webdavServerStatus();
+        const webdavConfigs = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (status === 'online') {
             core_1.ux.log(`\nWebDav server status: ${core_1.ux.colorize('green', 'online')}\n`);
-            cli_utils_1.CLIUtils.success(`Internxt WebDav server started successfully on https://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${process.env.WEBDAV_SERVER_PORT}`);
+            cli_utils_1.CLIUtils.success(`Internxt WebDav server started successfully at ${webdavConfigs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${webdavConfigs.port}`);
+            core_1.ux.log(`\n[If the above URL is not working, the WebDAV server can be accessed directly via your localhost IP at: ${webdavConfigs.protocol}://127.0.0.1:${webdavConfigs.port} ]\n`);
             const authDetails = await auth_service_1.AuthService.instance.getAuthDetails();
             await analytics_service_1.AnalyticsService.instance.track('WebDAVEnabled', { app: 'internxt-cli', userId: authDetails.user.uuid });
         }

package/dist/database/migrations/20241018114828-add-parent-column.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/database/migrations/20241018114828-add-parent-column.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+module.exports = {
+    async up(queryInterface, Sequelize) {
+        await queryInterface.addColumn('folders', 'parent_uuid', {
+            type: Sequelize.UUIDV4,
+            references: {
+                model: 'folders',
+                key: 'uuid',
+            },
+        });
+        await queryInterface.addColumn('files', 'folder_uuid', {
+            type: Sequelize.UUIDV4,
+            references: {
+                model: 'files',
+                key: 'uuid',
+            },
+        });
+    },
+    async down(queryInterface) {
+        await queryInterface.removeColumn('folders', 'parent_uuid');
+        await queryInterface.removeColumn('files', 'folder_uuid');
+    },
+};

package/dist/hooks/prerun/auth_check.js

@@ -12,7 +12,8 @@ const sdk_manager_service_1 = require("../../services/sdk-manager.service");
 const auth_service_1 = require("../../services/auth.service");
 const command_types_1 = require("../../types/command.types");
 const webdav_1 = __importDefault(require("../../commands/webdav"));
-const CommandsToSkip = [whoami_1.default, login_1.default, logout_1.default, logs_1.default, webdav_1.default];
+const webdav_config_1 = __importDefault(require("../../commands/webdav-config"));
+const CommandsToSkip = [whoami_1.default, login_1.default, logout_1.default, logs_1.default, webdav_1.default, webdav_config_1.default];
 const hook = async function (opts) {
     if (!CommandsToSkip.map((command) => command.name).includes(opts.Command.name)) {
         cli_utils_1.CLIUtils.doing('Checking credentials');

package/dist/services/analytics.service.d.ts

@@ -1,4 +1,3 @@
-import { apiObject } from '@rudderstack/rudder-sdk-node';
 import { ConfigService } from './config.service';
 export declare const AnalyticsEvents: {
     CLILogin: string;
@@ -6,14 +5,18 @@ export declare const AnalyticsEvents: {
     WebDAVRequest: string;
 };
 export declare class AnalyticsService {
-    private config;
+    private readonly config;
     static readonly instance: AnalyticsService;
     constructor(config: ConfigService);
-    private getRudderstack;
-    private platformShortName;
-    private platformFamily;
     track(eventKey: keyof typeof AnalyticsEvents, options: {
         app: 'internxt-cli' | 'internxt-webdav';
         userId: string;
-    }, params?: apiObject): void;
+    }, params?: object): Promise<{
+        eventKey: "CLILogin" | "WebDAVEnabled" | "WebDAVRequest";
+        options: {
+            app: 'internxt-cli' | 'internxt-webdav';
+            userId: string;
+        };
+        params: object;
+    }>;
 }

package/dist/services/analytics.service.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyticsService = exports.AnalyticsEvents = void 0;
-const rudder_sdk_node_1 = __importDefault(require("@rudderstack/rudder-sdk-node"));
 const config_service_1 = require("./config.service");
 exports.AnalyticsEvents = {
     CLILogin: 'CLI Login',
@@ -17,37 +13,8 @@ class AnalyticsService {
     constructor(config) {
         this.config = config;
     }
-    getRudderstack() {
-        return new rudder_sdk_node_1.default(this.config.get('RUDDERSTACK_WRITE_KEY'), {
-            dataPlaneUrl: this.config.get('RUDDERSTACK_DATAPLANE_URL'),
-        });
-    }
-    platformShortName(platform) {
-        switch (platform) {
-            case 'darwin':
-                return 'MAC';
-            case 'win32':
-                return 'WIN';
-            case 'linux':
-                return 'LINUX';
-            default:
-                return '';
-        }
-    }
-    platformFamily(platform) {
-        switch (platform) {
-            case 'darwin':
-                return 'Mac';
-            case 'win32':
-                return 'Windows';
-            case 'linux':
-                return 'Linux';
-            default:
-                return 'Unknown';
-        }
-    }
-    track(eventKey, options, params = {}) {
-        return;
+    async track(eventKey, options, params = {}) {
+        return { eventKey, options, params };
     }
 }
 exports.AnalyticsService = AnalyticsService;

package/dist/services/config.service.d.ts

@@ -1,5 +1,5 @@
 import { ConfigKeys } from '../types/config.types';
-import { CLICredentials } from '../types/command.types';
+import { CLICredentials, WebdavConfig } from '../types/command.types';
 export declare class ConfigService {
     static readonly INTERNXT_CLI_DATA_DIR: string;
     static readonly INTERNXT_CLI_LOGS_DIR: string;
@@ -7,12 +7,17 @@ export declare class ConfigService {
     static readonly CREDENTIALS_FILE: string;
     static readonly DRIVE_SQLITE_FILE: string;
     static readonly WEBDAV_SSL_CERTS_DIR: string;
+    static readonly WEBDAV_CONFIGS_FILE: string;
     static readonly WEBDAV_LOCAL_URL = "webdav.local.internxt.com";
+    static readonly WEBDAV_DEFAULT_PORT = "3005";
+    static readonly WEBDAV_DEFAULT_PROTOCOL = "https";
     static readonly instance: ConfigService;
     get: (key: keyof ConfigKeys) => string;
     saveUser: (loginCredentials: CLICredentials) => Promise<void>;
     clearUser: () => Promise<void>;
     readUser: () => Promise<CLICredentials | undefined>;
+    saveWebdavConfig: (webdavConfig: WebdavConfig) => Promise<void>;
+    readWebdavConfig: () => Promise<WebdavConfig>;
     ensureInternxtCliDataDirExists: () => Promise<void>;
     ensureWebdavCertsDirExists: () => Promise<void>;
     ensureInternxtLogsDirExists: () => Promise<void>;

package/dist/services/config.service.js

@@ -15,7 +15,10 @@ class ConfigService {
     static CREDENTIALS_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, '.inxtcli');
     static DRIVE_SQLITE_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
     static WEBDAV_SSL_CERTS_DIR = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
+    static WEBDAV_CONFIGS_FILE = path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
     static WEBDAV_LOCAL_URL = 'webdav.local.internxt.com';
+    static WEBDAV_DEFAULT_PORT = '3005';
+    static WEBDAV_DEFAULT_PROTOCOL = 'https';
     static instance = new ConfigService();
     get = (key) => {
         const value = process.env[key];
@@ -51,6 +54,27 @@ class ConfigService {
             return;
         }
     };
+    saveWebdavConfig = async (webdavConfig) => {
+        await this.ensureInternxtCliDataDirExists();
+        const configs = JSON.stringify(webdavConfig);
+        await promises_1.default.writeFile(ConfigService.WEBDAV_CONFIGS_FILE, configs, 'utf8');
+    };
+    readWebdavConfig = async () => {
+        try {
+            const configsData = await promises_1.default.readFile(ConfigService.WEBDAV_CONFIGS_FILE, 'utf8');
+            const configs = JSON.parse(configsData);
+            return {
+                port: configs?.port ?? ConfigService.WEBDAV_DEFAULT_PORT,
+                protocol: configs?.protocol ?? ConfigService.WEBDAV_DEFAULT_PROTOCOL,
+            };
+        }
+        catch {
+            return {
+                port: ConfigService.WEBDAV_DEFAULT_PORT,
+                protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
+            };
+        }
+    };
     ensureInternxtCliDataDirExists = async () => {
         try {
             await promises_1.default.access(ConfigService.INTERNXT_CLI_DATA_DIR);

package/dist/services/database/drive-database-manager.service.d.ts

@@ -4,17 +4,20 @@ import { DriveFolderRepository } from './drive-folder/drive-folder.repository';
 import { DriveFile } from './drive-file/drive-file.domain';
 import { DriveFolder } from './drive-folder/drive-folder.domain';
 export declare class DriveDatabaseManager {
-    private driveFileRepository;
-    private driveFolderRepository;
+    private readonly driveFileRepository;
+    private readonly driveFolderRepository;
     private static readonly sequelize;
     constructor(driveFileRepository: DriveFileRepository, driveFolderRepository: DriveFolderRepository);
     static readonly init: () => Promise<void>;
     static readonly clean: () => Promise<void>;
-    findByRelativePath: (relativePath: string) => Promise<DriveFolder | DriveFile | null>;
-    createFolder: (driveFolder: DriveFolderItem) => Promise<DriveFolder>;
-    createFile: (driveFile: DriveFileItem) => Promise<DriveFile>;
+    findFileByRelativePath: (relativePath: string) => Promise<DriveFile | null>;
+    findFolderByRelativePath: (relativePath: string) => Promise<DriveFolder | null>;
+    createFolder: (driveFolder: DriveFolderItem, relativePath: string) => Promise<DriveFolder>;
+    createFile: (driveFile: DriveFileItem, relativePath: string) => Promise<DriveFile>;
     buildRelativePathForFile: (fileName: string, parentId: number | null) => Promise<string>;
     buildRelativePathForFolder: (folderName: string, parentId: number | null) => Promise<string>;
-    deleteFile: (id: number) => Promise<void>;
-    deleteFolder: (id: number) => Promise<void>;
+    deleteFileById: (id: number) => Promise<void>;
+    deleteFolderById: (id: number) => Promise<void>;
+    deleteFileByPath: (relativePath: string) => Promise<void>;
+    deleteFolderByPath: (relativePath: string) => Promise<void>;
 }

package/dist/services/database/drive-database-manager.service.js

@@ -25,36 +25,29 @@ class DriveDatabaseManager {
         this.driveFolderRepository = driveFolderRepository;
     }
     static init = async () => {
-        await DriveDatabaseManager.sequelize.sync();
+        await DriveDatabaseManager.sequelize.sync({ force: true });
     };
     static clean = async () => {
         await drive_file_repository_1.DriveFileRepository.clean();
         await drive_folder_repository_1.DriveFolderRepository.clean();
     };
-    findByRelativePath = async (relativePath) => {
+    findFileByRelativePath = async (relativePath) => {
         const driveFile = await this.driveFileRepository.findByRelativePath(relativePath);
-        if (driveFile)
-            return driveFile;
-        let folderRelativePath = relativePath;
-        if (!relativePath.endsWith('/'))
-            folderRelativePath = relativePath.concat('/');
+        return driveFile ?? null;
+    };
+    findFolderByRelativePath = async (relativePath) => {
+        const folderRelativePath = relativePath.endsWith('/') ? relativePath : relativePath.concat('/');
         const driveFolder = await this.driveFolderRepository.findByRelativePath(folderRelativePath);
-        if (driveFolder)
-            return driveFolder;
-        return null;
+        return driveFolder ?? null;
     };
-    createFolder = async (driveFolder) => {
-        const relativePath = await this.buildRelativePathForFolder(driveFolder.name, driveFolder.parentId ?? null);
-        const existingObject = await this.driveFolderRepository.findById(driveFolder.id);
-        if (existingObject)
-            await this.driveFolderRepository.deleteById(existingObject.id);
+    createFolder = async (driveFolder, relativePath) => {
+        await this.deleteFolderById(driveFolder.id);
+        await this.deleteFolderByPath(relativePath);
         return await this.driveFolderRepository.createFolder(driveFolder, relativePath);
     };
-    createFile = async (driveFile) => {
-        const relativePath = await this.buildRelativePathForFile(driveFile.type ? `${driveFile.name}.${driveFile.type}` : driveFile.name, driveFile.folderId);
-        const existingObject = await this.driveFileRepository.findById(driveFile.id);
-        if (existingObject)
-            await this.driveFileRepository.deleteById(existingObject.id);
+    createFile = async (driveFile, relativePath) => {
+        await this.deleteFileById(driveFile.id);
+        await this.deleteFileByPath(relativePath);
         return await this.driveFileRepository.createFile(driveFile, relativePath);
     };
     buildRelativePathForFile = async (fileName, parentId) => {
@@ -73,11 +66,28 @@ class DriveDatabaseManager {
         const parentPath = await this.buildRelativePathForFolder(parentFolder.name, parentFolder.parentId);
         return webdav_utils_1.WebDavUtils.joinURL(parentPath, folderName, '/');
     };
-    deleteFile = (id) => {
-        return this.driveFileRepository.deleteById(id);
+    deleteFileById = async (id) => {
+        const existingObject = await this.driveFileRepository.findById(id);
+        if (existingObject) {
+            await this.driveFileRepository.deleteById(existingObject.id);
+        }
+    };
+    deleteFolderById = async (id) => {
+        const existingObject = await this.driveFolderRepository.findById(id);
+        if (existingObject) {
+            await this.driveFolderRepository.deleteById(existingObject.id);
+        }
     };
-    deleteFolder = (id) => {
-        return this.driveFolderRepository.deleteById(id);
+    deleteFileByPath = async (relativePath) => {
+        const existingPath = await this.driveFileRepository.findByRelativePath(relativePath);
+        if (existingPath)
+            await this.driveFileRepository.deleteById(existingPath.id);
+    };
+    deleteFolderByPath = async (relativePath) => {
+        const existingPath = await this.driveFolderRepository.findByRelativePath(relativePath);
+        if (existingPath) {
+            await this.driveFolderRepository.deleteById(existingPath.id);
+        }
     };
 }
 exports.DriveDatabaseManager = DriveDatabaseManager;

package/dist/services/database/drive-file/drive-file.attributes.d.ts

@@ -5,6 +5,7 @@ export interface DriveFileAttributes {
     uuid: string;
     fileId: string;
     folderId: number;
+    folderUuid: string;
     bucket: string;
     relativePath: string;
     createdAt: Date;

package/dist/services/database/drive-file/drive-file.domain.d.ts

@@ -1,3 +1,4 @@
+import { DriveFileItem } from '../../../types/drive.types';
 import { DriveFileAttributes } from './drive-file.attributes';
 export declare class DriveFile implements DriveFileAttributes {
     id: number;
@@ -6,13 +7,15 @@ export declare class DriveFile implements DriveFileAttributes {
     uuid: string;
     fileId: string;
     folderId: number;
+    folderUuid: string;
     bucket: string;
     relativePath: string;
     createdAt: Date;
     updatedAt: Date;
     size: number;
     status: string;
-    constructor({ id, name, type, uuid, fileId, folderId, bucket, relativePath, createdAt, updatedAt, size, status, }: DriveFileAttributes);
+    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, }: DriveFileAttributes);
     static build(file: DriveFileAttributes): DriveFile;
     toJSON(): DriveFileAttributes;
+    toItem(): DriveFileItem;
 }

package/dist/services/database/drive-file/drive-file.domain.js

@@ -8,19 +8,21 @@ class DriveFile {
     uuid;
     fileId;
     folderId;
+    folderUuid;
     bucket;
     relativePath;
     createdAt;
     updatedAt;
     size;
     status;
-    constructor({ id, name, type, uuid, fileId, folderId, bucket, relativePath, createdAt, updatedAt, size, status, }) {
+    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, }) {
         this.id = id;
         this.name = name;
         this.type = type;
         this.uuid = uuid;
         this.fileId = fileId;
         this.folderId = folderId;
+        this.folderUuid = folderUuid;
         this.bucket = bucket;
         this.relativePath = relativePath;
         this.createdAt = createdAt;
@@ -39,6 +41,7 @@ class DriveFile {
             uuid: this.uuid,
             fileId: this.fileId,
             folderId: this.folderId,
+            folderUuid: this.folderUuid,
             bucket: this.bucket,
             relativePath: this.relativePath,
             createdAt: this.createdAt,
@@ -47,5 +50,22 @@ class DriveFile {
             status: this.status,
         };
     }
+    toItem() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            uuid: this.uuid,
+            fileId: this.fileId,
+            folderId: this.folderId,
+            folderUuid: this.folderUuid,
+            bucket: this.bucket,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            size: this.size,
+            status: this.status,
+            encryptedName: '',
+        };
+    }
 }
 exports.DriveFile = DriveFile;

package/dist/services/database/drive-file/drive-file.model.d.ts

@@ -7,6 +7,7 @@ export declare class DriveFileModel extends Model implements DriveFileAttributes
     uuid: string;
     fileId: string;
     folderId: number;
+    folderUuid: string;
     bucket: string;
     relativePath: string;
     size: number;

package/dist/services/database/drive-file/drive-file.model.js

@@ -43,6 +43,10 @@ __decorate([
     (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.INTEGER),
     __metadata("design:type", Number)
 ], DriveFileModel.prototype, "folderId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.UUIDV4),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "folderUuid", void 0);
 __decorate([
     (0, sequelize_typescript_1.Column)(sequelize_typescript_1.DataType.STRING(24)),
     __metadata("design:type", String)

package/dist/services/database/drive-folder/drive-folder.attributes.d.ts

@@ -5,6 +5,7 @@ export interface DriveFolderAttributes {
     status: 'EXISTS' | 'TRASHED';
     relativePath: string;
     parentId: number | null;
+    parentUuid: string | null;
     createdAt: Date;
     updatedAt: Date;
 }