@internxt/cli 1.5.7 → 1.6.0

package/dist/commands/webdav-config.js

@@ -39,16 +39,20 @@ class WebDAVConfig extends core_1.Command {
             required: false,
             min: 0,
         }),
+        createFullPath: core_1.Flags.boolean({
+            char: 'c',
+            description: 'Auto-create missing parent directories during file uploads.',
+            required: false,
+            allowNo: true,
+        }),
     };
     static enableJsonFlag = true;
     run = async () => {
-        const { flags } = await this.parse(WebDAVConfig);
+        const { flags: { host, port, http, https, timeout, createFullPath }, } = await this.parse(WebDAVConfig);
         const webdavConfig = await config_service_1.ConfigService.instance.readWebdavConfig();
-        const host = flags['host'];
         if (host) {
             webdavConfig['host'] = host;
         }
-        const port = flags['port'];
         if (port) {
             if (validation_service_1.ValidationService.instance.validateTCPIntegerPort(port)) {
                 webdavConfig['port'] = port;
@@ -57,18 +61,18 @@ class WebDAVConfig extends core_1.Command {
                 throw new command_types_1.NotValidPortError();
             }
         }
-        const http = flags['http'];
         if (http) {
             webdavConfig['protocol'] = 'http';
         }
-        const https = flags['https'];
         if (https) {
             webdavConfig['protocol'] = 'https';
         }
-        const timeout = flags['timeout'];
         if (timeout !== undefined) {
             webdavConfig['timeoutMinutes'] = timeout;
         }
+        if (createFullPath !== undefined) {
+            webdavConfig['createFullPath'] = createFullPath;
+        }
         await config_service_1.ConfigService.instance.saveWebdavConfig(webdavConfig);
         const message = `On the next start, the WebDAV server will use the next config: ${JSON.stringify(webdavConfig)}`;
         cli_utils_1.CLIUtils.success(this.log.bind(this), message);
@@ -80,7 +84,6 @@ class WebDAVConfig extends core_1.Command {
             error,
             command: this.id,
             logReporter: this.log.bind(this),
-            errorReporter: this.error.bind(this),
             jsonFlag: flags['json'],
         });
         this.exit(1);

package/dist/commands/webdav.js

@@ -62,7 +62,6 @@ class Webdav extends core_1.Command {
             error,
             command: this.id,
             logReporter: this.log.bind(this),
-            errorReporter: this.error.bind(this),
             jsonFlag: flags['json'],
         });
         this.exit(1);

package/dist/commands/whoami.js

@@ -30,7 +30,7 @@ class Whoami extends core_1.Command {
             else {
                 if (validCreds.refreshRequired) {
                     try {
-                        await auth_service_1.AuthService.instance.refreshUserToken(userCredentials);
+                        await auth_service_1.AuthService.instance.refreshUserToken(userCredentials.token, userCredentials.user.mnemonic);
                     }
                     catch {
                     }
@@ -47,7 +47,6 @@ class Whoami extends core_1.Command {
             error,
             command: this.id,
             logReporter: this.log.bind(this),
-            errorReporter: this.error.bind(this),
             jsonFlag: flags['json'],
         });
         this.exit(1);

package/dist/hooks/prerun/auth_check.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const whoami_1 = __importDefault(require("../../commands/whoami"));
 const login_1 = __importDefault(require("../../commands/login"));
+const login_legacy_1 = __importDefault(require("../../commands/login-legacy"));
 const logout_1 = __importDefault(require("../../commands/logout"));
 const logs_1 = __importDefault(require("../../commands/logs"));
 const cli_utils_1 = require("../../utils/cli.utils");
@@ -12,7 +13,7 @@ const sdk_manager_service_1 = require("../../services/sdk-manager.service");
 const auth_service_1 = require("../../services/auth.service");
 const webdav_1 = __importDefault(require("../../commands/webdav"));
 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 CommandsToSkip = [whoami_1.default, login_1.default, login_legacy_1.default, logout_1.default, logs_1.default, webdav_1.default, webdav_config_1.default];
 const hook = async function (opts) {
     const { Command, argv } = opts;
     const jsonFlag = argv.includes('--json');
@@ -30,7 +31,6 @@ const hook = async function (opts) {
                 error: err,
                 command: Command.id,
                 logReporter: this.log.bind(this),
-                errorReporter: this.error.bind(this),
                 jsonFlag,
             });
             opts.context.exit(1);

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

@@ -4,7 +4,6 @@ export declare class AuthService {
     doLogin: (email: string, password: string, twoFactorCode?: string) => Promise<LoginCredentials>;
     is2FANeeded: (email: string) => Promise<boolean>;
     getAuthDetails: () => Promise<LoginCredentials>;
-    refreshUserDetails: (oldCreds: LoginCredentials) => Promise<LoginCredentials>;
-    refreshUserToken: (oldCreds: LoginCredentials) => Promise<LoginCredentials>;
+    refreshUserToken: (oldToken: string, mnemonic: string) => Promise<LoginCredentials>;
     logout: () => Promise<void>;
 }

package/dist/services/auth.service.js

@@ -25,8 +25,6 @@ class AuthService {
         return {
             user: clearUser,
             token: newToken,
-            lastLoggedInAt: new Date().toISOString(),
-            lastTokenRefreshAt: new Date().toISOString(),
         };
     };
     is2FANeeded = async (email) => {
@@ -51,38 +49,25 @@ class AuthService {
         }
         const refreshToken = tokenDetails.expiration.refreshRequired;
         if (refreshToken) {
-            loginCreds = await this.refreshUserToken(loginCreds);
+            loginCreds = await this.refreshUserToken(loginCreds.token, loginCreds.user.mnemonic);
         }
         return loginCreds;
     };
-    refreshUserDetails = async (oldCreds) => {
-        sdk_manager_service_1.SdkManager.init({ token: oldCreds.token });
+    refreshUserToken = async (oldToken, mnemonic) => {
+        sdk_manager_service_1.SdkManager.init({ token: oldToken });
+        const isValidMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(mnemonic);
+        if (!isValidMnemonic) {
+            throw new command_types_1.InvalidCredentialsError();
+        }
         const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers();
-        const newCreds = await usersClient.getUserData({ userUuid: oldCreds.user.uuid });
-        const loginCreds = {
+        const newCreds = await usersClient.refreshUserCredentials();
+        sdk_manager_service_1.SdkManager.init({ token: newCreds.newToken });
+        const newLoginCreds = {
             user: {
                 ...newCreds.user,
-                mnemonic: oldCreds.user.mnemonic,
-                createdAt: new Date(newCreds.user.createdAt).toISOString(),
+                mnemonic: mnemonic,
             },
             token: newCreds.newToken,
-            lastLoggedInAt: oldCreds.lastLoggedInAt,
-            lastTokenRefreshAt: new Date().toISOString(),
-        };
-        sdk_manager_service_1.SdkManager.init({ token: newCreds.newToken });
-        await config_service_1.ConfigService.instance.saveUser(loginCreds);
-        return loginCreds;
-    };
-    refreshUserToken = async (oldCreds) => {
-        sdk_manager_service_1.SdkManager.init({ token: oldCreds.token });
-        const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers();
-        const newCreds = await usersClient.refreshUser();
-        sdk_manager_service_1.SdkManager.init({ token: newCreds.newToken });
-        const newLoginCreds = {
-            ...oldCreds,
-            token: newCreds.newToken,
-            lastLoggedInAt: oldCreds.lastLoggedInAt,
-            lastTokenRefreshAt: new Date().toISOString(),
         };
         await config_service_1.ConfigService.instance.saveUser(newLoginCreds);
         return newLoginCreds;

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

@@ -12,6 +12,7 @@ export declare class ConfigService {
     static readonly WEBDAV_DEFAULT_PORT = "3005";
     static readonly WEBDAV_DEFAULT_PROTOCOL = "https";
     static readonly WEBDAV_DEFAULT_TIMEOUT = 0;
+    static readonly WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
     static readonly instance: ConfigService;
     get: (key: keyof ConfigKeys) => string;
     saveUser: (loginCredentials: LoginCredentials) => Promise<void>;

package/dist/services/config.service.js

@@ -20,6 +20,7 @@ class ConfigService {
     static WEBDAV_DEFAULT_PORT = '3005';
     static WEBDAV_DEFAULT_PROTOCOL = 'https';
     static WEBDAV_DEFAULT_TIMEOUT = 0;
+    static WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
     static instance = new ConfigService();
     get = (key) => {
         const value = process.env[key];
@@ -64,6 +65,7 @@ class ConfigService {
                 port: configs?.port ?? ConfigService.WEBDAV_DEFAULT_PORT,
                 protocol: configs?.protocol ?? ConfigService.WEBDAV_DEFAULT_PROTOCOL,
                 timeoutMinutes: configs?.timeoutMinutes ?? ConfigService.WEBDAV_DEFAULT_TIMEOUT,
+                createFullPath: configs?.createFullPath ?? ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
             };
         }
         catch {
@@ -72,6 +74,7 @@ class ConfigService {
                 port: ConfigService.WEBDAV_DEFAULT_PORT,
                 protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
                 timeoutMinutes: ConfigService.WEBDAV_DEFAULT_TIMEOUT,
+                createFullPath: ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
             };
         }
     };

package/dist/services/crypto.service.js

@@ -104,7 +104,7 @@ class CryptoService {
     };
     getKeyAndIvFrom = (secret, salt) => {
         const TRANSFORM_ROUNDS = 3;
-        const password = Buffer.concat([Buffer.from(secret, 'binary'), salt]);
+        const password = Buffer.concat([Buffer.from(secret, 'utf8'), salt]);
         const md5Hashes = [];
         let digest = password;
         for (let i = 0; i < TRANSFORM_ROUNDS; i++) {

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

@@ -58,6 +58,7 @@ class DriveFile {
     }
     toItem() {
         return {
+            itemType: 'file',
             id: this.id,
             name: this.name,
             type: this.type,

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

@@ -40,6 +40,7 @@ class DriveFolder {
     }
     toItem() {
         return {
+            itemType: 'folder',
             id: this.id,
             name: this.name,
             uuid: this.uuid,

package/dist/services/drive/drive-file.service.js

@@ -9,6 +9,7 @@ class DriveFileService {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const driveFile = await storageClient.createFileEntryByUuid(payload);
         return {
+            itemType: 'file',
             name: payload.plainName,
             id: driveFile.id,
             uuid: driveFile.uuid,

package/dist/services/universal-link.service.d.ts

@@ -0,0 +1,10 @@
+import { LoginCredentials } from '../types/command.types';
+export declare class UniversalLinkService {
+    static readonly instance: UniversalLinkService;
+    getUserCredentials: (userSession: {
+        mnemonic: string;
+        token: string;
+    }) => Promise<LoginCredentials>;
+    buildLoginUrl: (redirectUri: string) => string;
+    loginSSO: (jsonFlag: boolean, reporter: (message: string) => void, hostIp?: string, forcedPort?: number) => Promise<LoginCredentials>;
+}

package/dist/services/universal-link.service.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalLinkService = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const open_1 = __importDefault(require("open"));
+const config_service_1 = require("./config.service");
+const auth_service_1 = require("./auth.service");
+const cli_utils_1 = require("../utils/cli.utils");
+class UniversalLinkService {
+    static instance = new UniversalLinkService();
+    getUserCredentials = async (userSession) => {
+        const clearMnemonic = Buffer.from(userSession.mnemonic, 'base64').toString('utf-8');
+        const clearToken = Buffer.from(userSession.token, 'base64').toString('utf-8');
+        const loginCredentials = await auth_service_1.AuthService.instance.refreshUserToken(clearToken, clearMnemonic);
+        return {
+            user: {
+                ...loginCredentials.user,
+                mnemonic: clearMnemonic,
+            },
+            token: clearToken,
+        };
+    };
+    buildLoginUrl = (redirectUri) => {
+        const loginURL = `${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/login`;
+        const params = new URLSearchParams({
+            universalLink: 'true',
+            redirectUri: redirectUri,
+        });
+        return `${loginURL}?${params.toString()}`;
+    };
+    loginSSO = async (jsonFlag, reporter, hostIp = '127.0.0.1', forcedPort = 0) => {
+        return new Promise((resolve, reject) => {
+            const server = node_http_1.default.createServer(async (req, res) => {
+                if (!req.url)
+                    return;
+                const parsedUrl = new URL(req.url, `http://${req.headers.host}`);
+                const driveUrl = config_service_1.ConfigService.instance.get('DRIVE_WEB_URL');
+                try {
+                    const mnemonic = parsedUrl.searchParams.get('mnemonic');
+                    const token = parsedUrl.searchParams.get('newToken');
+                    if (!mnemonic || !token) {
+                        throw new Error('Login has failed, please try again');
+                    }
+                    const loginCredentials = await this.getUserCredentials({ mnemonic, token });
+                    res.writeHead(302, {
+                        Location: `${driveUrl}/auth-link-ok`,
+                    });
+                    res.end();
+                    resolve(loginCredentials);
+                }
+                catch (error) {
+                    res.writeHead(302, {
+                        Location: `${driveUrl}/auth-link-error`,
+                    });
+                    res.end();
+                    reject(error);
+                }
+                finally {
+                    server.closeAllConnections();
+                    server.close();
+                }
+            });
+            server.listen(forcedPort, async () => {
+                const { port } = server.address();
+                const redirectUri = Buffer.from(`http://${hostIp}:${port}/callback`).toString('base64');
+                const loginUrl = this.buildLoginUrl(redirectUri);
+                cli_utils_1.CLIUtils.log(reporter, 'Opening browser for login...');
+                cli_utils_1.CLIUtils.log(reporter, 'If the browser doesn’t open automatically, visit:');
+                const printLoginUrl = jsonFlag ? `{ "loginUrl": "${loginUrl}" }` : loginUrl;
+                cli_utils_1.CLIUtils.consoleLog(printLoginUrl);
+                try {
+                    await (0, open_1.default)(loginUrl);
+                }
+                catch {
+                    cli_utils_1.CLIUtils.warning(reporter, 'Could not open browser automatically.');
+                }
+                cli_utils_1.CLIUtils.log(reporter, 'Waiting for authentication...');
+            });
+        });
+    };
+}
+exports.UniversalLinkService = UniversalLinkService;

package/dist/types/command.types.d.ts

@@ -26,14 +26,13 @@ export interface LoginUserDetails {
 export interface LoginCredentials {
     user: LoginUserDetails;
     token: string;
-    lastLoggedInAt: string;
-    lastTokenRefreshAt: string;
 }
 export interface WebdavConfig {
     host: string;
     port: string;
     protocol: 'http' | 'https';
     timeoutMinutes: number;
+    createFullPath: boolean;
 }
 export declare class NotValidEmailError extends Error {
     constructor();

package/dist/types/drive.types.d.ts

@@ -1,5 +1,6 @@
 import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
 export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
+    itemType: 'file';
     size: number;
     createdAt: Date;
     updatedAt: Date;
@@ -8,6 +9,7 @@ export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVers
     type?: string | null;
 };
 export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+    itemType: 'folder';
     encryptedName: string;
     uuid: string;
     createdAt: Date;
@@ -15,3 +17,4 @@ export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | '
     status: 'EXISTS' | 'TRASHED';
     parentUuid: string | null;
 };
+export type DriveItem = DriveFileItem | DriveFolderItem;

package/dist/types/webdav.types.d.ts

@@ -7,7 +7,6 @@ export type WebDavMethodHandlerOptions = {
     debug: boolean;
 };
 export type WebDavRequestedResource = {
-    type: 'file' | 'folder';
     url: string;
     name: string;
     path: ParsedPath;

package/dist/utils/cli.utils.d.ts

@@ -36,11 +36,10 @@ export declare class CLIUtils {
     static readonly timer: () => {
         stop: () => number;
     };
-    static readonly catchError: ({ error, logReporter, errorReporter, command, jsonFlag, }: {
+    static readonly catchError: ({ error, logReporter, command, jsonFlag, }: {
         error: Error;
         command?: string;
         logReporter: (message: string) => void;
-        errorReporter: (message: string) => void;
         jsonFlag?: boolean;
     }) => void;
     static readonly parseEmpty: (input: string) => Promise<string>;

package/dist/utils/cli.utils.js

@@ -130,7 +130,7 @@ class CLIUtils {
             },
         };
     };
-    static catchError = ({ error, logReporter, errorReporter, command, jsonFlag, }) => {
+    static catchError = ({ error, logReporter, command, jsonFlag, }) => {
         let message;
         if ('message' in error && error.message.trim().length > 0) {
             message = error.message;
@@ -143,7 +143,7 @@ class CLIUtils {
             CLIUtils.consoleLog(JSON.stringify({ success: false, message }));
         }
         else {
-            errors_utils_1.ErrorUtils.report(errorReporter, error, { command });
+            errors_utils_1.ErrorUtils.report(error, { command });
             CLIUtils.error(logReporter, message);
         }
     };

package/dist/utils/drive.utils.d.ts

@@ -1,6 +1,7 @@
-import { FileMeta, FolderMeta } from '@internxt/sdk/dist/drive/storage/types';
+import { FileMeta, FolderMeta, CreateFolderResponse } from '@internxt/sdk/dist/drive/storage/types';
 import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
 export declare class DriveUtils {
     static driveFileMetaToItem(fileMeta: FileMeta): DriveFileItem;
     static driveFolderMetaToItem(folderMeta: FolderMeta): DriveFolderItem;
+    static createFolderResponseToItem(folderResponse: CreateFolderResponse): DriveFolderItem;
 }

package/dist/utils/drive.utils.js

@@ -4,6 +4,7 @@ exports.DriveUtils = void 0;
 class DriveUtils {
     static driveFileMetaToItem(fileMeta) {
         return {
+            itemType: 'file',
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
             folderId: fileMeta.folderId,
@@ -22,6 +23,7 @@ class DriveUtils {
     }
     static driveFolderMetaToItem(folderMeta) {
         return {
+            itemType: 'folder',
             uuid: folderMeta.uuid,
             id: folderMeta.id,
             bucket: folderMeta.bucket,
@@ -34,5 +36,20 @@ class DriveUtils {
             updatedAt: new Date(folderMeta.updatedAt),
         };
     }
+    static createFolderResponseToItem(folderResponse) {
+        return {
+            itemType: 'folder',
+            uuid: folderResponse.uuid,
+            id: folderResponse.id,
+            bucket: folderResponse.bucket,
+            status: folderResponse.deleted || folderResponse.removed ? 'TRASHED' : 'EXISTS',
+            name: folderResponse.plainName ?? folderResponse.name,
+            encryptedName: folderResponse.name,
+            parentId: folderResponse.parentId,
+            parentUuid: folderResponse.parentUuid,
+            createdAt: new Date(folderResponse.createdAt),
+            updatedAt: new Date(folderResponse.updatedAt),
+        };
+    }
 }
 exports.DriveUtils = DriveUtils;

package/dist/utils/errors.utils.d.ts

@@ -1,5 +1,6 @@
+export declare function isError(error: unknown): error is Error;
 export declare class ErrorUtils {
-    static report(reporter: (error: string) => void, error: unknown, props?: Record<string, unknown>): void;
+    static report(error: unknown, props?: Record<string, unknown>): void;
 }
 export declare class ConflictError extends Error {
     statusCode: number;

package/dist/utils/errors.utils.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
+exports.isError = isError;
+const logger_utils_1 = require("./logger.utils");
+const node_util_1 = require("node:util");
+function isError(error) {
+    return node_util_1.types.isNativeError(error);
+}
 class ErrorUtils {
-    static report(reporter, error, props = {}) {
-        if (error instanceof Error) {
-            reporter(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
+    static report(error, props = {}) {
+        if (isError(error)) {
+            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
         }
         else {
-            reporter(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
+            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
         }
     }
 }

package/dist/utils/webdav.utils.d.ts

@@ -1,15 +1,29 @@
-import { Request } from 'express';
 import { WebDavRequestedResource } from '../types/webdav.types';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
 import { DriveFileService } from '../services/drive/drive-file.service';
-import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
+import { DriveFileItem, DriveFolderItem, DriveItem } from '../types/drive.types';
 export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
     static removeHostFromURL(completeURL: string): string;
-    static getRequestedResource(urlObject: string | Request, decodeUri?: boolean): Promise<WebDavRequestedResource>;
+    static decodeUrl(requestUrl: string, decodeUri?: boolean): string;
+    static normalizeFolderPath(path: string): string;
+    static getRequestedResource(requestUrl: string, decodeUri?: boolean): Promise<WebDavRequestedResource>;
+    static tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }: {
+        url: string;
+        driveFolderService: DriveFolderService;
+        driveFileService: DriveFileService;
+    }): Promise<DriveItem | undefined>;
+    static getDriveFileFromResource({ url, driveFileService, }: {
+        url: string;
+        driveFileService: DriveFileService;
+    }): Promise<DriveFileItem | undefined>;
+    static getDriveFolderFromResource({ url, driveFolderService, }: {
+        url: string;
+        driveFolderService: DriveFolderService;
+    }): Promise<DriveFolderItem | undefined>;
     static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
         resource: WebDavRequestedResource;
-        driveFolderService?: DriveFolderService;
-        driveFileService?: DriveFileService;
-    }): Promise<DriveFileItem | DriveFolderItem | undefined>;
+        driveFolderService: DriveFolderService;
+        driveFileService: DriveFileService;
+    }): Promise<DriveItem | undefined>;
 }

package/dist/utils/webdav.utils.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavUtils = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const logger_utils_1 = require("./logger.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -19,49 +20,67 @@ class WebDavUtils {
             url = '/'.concat(url);
         return url;
     }
-    static async getRequestedResource(urlObject, decodeUri = true) {
-        let requestUrl;
-        if (typeof urlObject === 'string') {
-            requestUrl = urlObject;
+    static decodeUrl(requestUrl, decodeUri = true) {
+        return (decodeUri ? decodeURIComponent(requestUrl) : requestUrl).replaceAll('/./', '/');
+    }
+    static normalizeFolderPath(path) {
+        let normalizedPath = path;
+        if (!normalizedPath.startsWith('/')) {
+            normalizedPath = `/${normalizedPath}`;
         }
-        else {
-            requestUrl = urlObject.url;
+        if (!normalizedPath.endsWith('/')) {
+            normalizedPath = `${normalizedPath}/`;
         }
-        const decodedUrl = (decodeUri ? decodeURIComponent(requestUrl) : requestUrl).replaceAll('/./', '/');
+        return normalizedPath;
+    }
+    static async getRequestedResource(requestUrl, decodeUri = true) {
+        const decodedUrl = this.decodeUrl(requestUrl, decodeUri);
         const parsedPath = node_path_1.default.parse(decodedUrl);
-        let parentPath = node_path_1.default.dirname(decodedUrl);
-        if (!parentPath.startsWith('/'))
-            parentPath = '/'.concat(parentPath);
-        if (!parentPath.endsWith('/'))
-            parentPath = parentPath.concat('/');
-        const isFolder = requestUrl.endsWith('/');
-        if (isFolder) {
-            return {
-                type: 'folder',
-                url: decodedUrl,
-                name: parsedPath.base,
-                path: parsedPath,
-                parentPath,
-            };
+        const parentPath = this.normalizeFolderPath(node_path_1.default.dirname(decodedUrl));
+        return {
+            url: decodedUrl,
+            name: parsedPath.base,
+            path: parsedPath,
+            parentPath,
+        };
+    }
+    static async tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }) {
+        try {
+            return await driveFileService.getFileMetadataByPath(url);
+        }
+        catch {
+            return await driveFolderService.getFolderMetadataByPath(url);
+        }
+    }
+    static async getDriveFileFromResource({ url, driveFileService, }) {
+        try {
+            return await driveFileService.getFileMetadataByPath(url);
+        }
+        catch (err) {
+            logger_utils_1.webdavLogger.error('Exception while getting the file metadata by path', err);
+        }
+    }
+    static async getDriveFolderFromResource({ url, driveFolderService, }) {
+        try {
+            return await driveFolderService.getFolderMetadataByPath(url);
         }
-        else {
-            return {
-                type: 'file',
-                url: decodedUrl,
-                name: parsedPath.name,
-                path: parsedPath,
-                parentPath,
-            };
+        catch (err) {
+            logger_utils_1.webdavLogger.error('Exception while getting the folder metadata by path', err);
         }
     }
     static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
         let item = undefined;
+        const isFolder = resource.url.endsWith('/');
         try {
-            if (resource.type === 'folder') {
-                item = await driveFolderService?.getFolderMetadataByPath(resource.url);
+            if (isFolder) {
+                item = await driveFolderService.getFolderMetadataByPath(resource.url);
             }
-            if (resource.type === 'file') {
-                item = await driveFileService?.getFileMetadataByPath(resource.url);
+            else {
+                item = await this.tryGetFileOrFolderMetadata({
+                    url: resource.url,
+                    driveFileService,
+                    driveFolderService,
+                });
             }
         }
         catch {