@internxt/cli 1.6.2 → 1.6.3

package/dist/{webdav/services → services/webdav}/webdav-folder.service.js

@@ -1,25 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavFolderService = void 0;
+const config_service_1 = require("../../services/config.service");
+const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const async_utils_1 = require("../../utils/async.utils");
 const auth_service_1 = require("../../services/auth.service");
 const drive_utils_1 = require("../../utils/drive.utils");
 class WebDavFolderService {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
+    static instance = new WebDavFolderService();
     getDriveFolderItemFromPath = async (path) => {
         const { url } = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
-        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
-            url,
-            driveFolderService: this.dependencies.driveFolderService,
-        });
+        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource(url);
     };
     createFolder = async ({ folderName, parentFolderUuid, }) => {
-        const [createFolderPromise] = this.dependencies.driveFolderService.createFolder({
+        const [createFolderPromise] = await drive_folder_service_1.DriveFolderService.instance.createFolder({
             plainName: folderName,
             parentFolderUuid: parentFolderUuid,
         });
@@ -28,7 +24,7 @@ class WebDavFolderService {
         return drive_utils_1.DriveUtils.createFolderResponseToItem(newFolder);
     };
     createParentPathOrThrow = async (parentPath) => {
-        const { createFullPath } = await this.dependencies.configService.readWebdavConfig();
+        const { createFullPath } = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (!createFullPath) {
             throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)},
         createFullPath flag is set to: ${createFullPath}`);

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

@@ -1,3 +1,5 @@
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { NetworkCredentials } from './network.types';
 export interface LoginUserDetails {
     userId: string;
     uuid: string;
@@ -23,9 +25,21 @@ export interface LoginUserDetails {
     avatar: string | null;
     emailVerified: boolean;
 }
+export interface WorkspaceCredentialsDetails {
+    id: string;
+    bucket: string;
+    workspaceUserId: string;
+    credentials: NetworkCredentials;
+    token: string;
+}
+export interface Workspace {
+    workspaceData: WorkspaceData;
+    workspaceCredentials: WorkspaceCredentialsDetails;
+}
 export interface LoginCredentials {
     user: LoginUserDetails;
     token: string;
+    workspace?: Workspace;
 }
 export interface WebdavConfig {
     host: string;
@@ -33,6 +47,10 @@ export interface WebdavConfig {
     protocol: 'http' | 'https';
     timeoutMinutes: number;
     createFullPath: boolean;
+    customAuth: boolean;
+    username: string;
+    password: string;
+    deleteFilesPermanently: boolean;
 }
 export declare class NotValidEmailError extends Error {
     constructor();
@@ -70,6 +88,12 @@ export declare class EmptyFileNameError extends Error {
 export declare class EmptyFolderNameError extends Error {
     constructor();
 }
+export declare class EmptyCustomAuthUsernameError extends Error {
+    constructor();
+}
+export declare class EmptyCustomAuthPasswordError extends Error {
+    constructor();
+}
 export declare class NotValidPortError extends Error {
     constructor();
 }
@@ -79,6 +103,12 @@ export declare class NotValidDirectoryError extends Error {
 export declare class NotValidFileError extends Error {
     constructor();
 }
+export declare class NotValidWorkspaceUuidError extends Error {
+    constructor();
+}
+export declare class MissingCredentialsWhenUsingAuthError extends Error {
+    constructor();
+}
 export interface PaginatedItem {
     name: string;
     type: string;
@@ -87,8 +117,21 @@ export interface PaginatedItem {
     modified: string;
 }
 export interface PromptOptions {
-    type: 'input' | 'password' | 'mask' | 'confirm';
+    type: 'input' | 'password' | 'mask' | 'confirm' | 'list';
     confirm?: {
         default: boolean;
     };
+    choices?: {
+        values: string[];
+        default?: number;
+    };
+}
+export interface PaginatedWorkspace {
+    name: string;
+    id: string;
+    usedSpace: string;
+    availableSpace: string;
+    owner: string;
+    address: string;
+    created: string;
 }

package/dist/types/command.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileIdError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
+exports.MissingCredentialsWhenUsingAuthError = exports.NotValidWorkspaceUuidError = exports.NotValidFileError = exports.NotValidDirectoryError = exports.NotValidPortError = exports.EmptyCustomAuthPasswordError = exports.EmptyCustomAuthUsernameError = exports.EmptyFolderNameError = exports.EmptyFileNameError = exports.InvalidCredentialsError = exports.ExpiredCredentialsError = exports.MissingCredentialsError = exports.NoRootFolderIdFoundError = exports.NotValidFileIdError = exports.NotValidFileUuidError = exports.NotValidFolderUuidError = exports.NotValidTwoFactorCodeError = exports.EmptyPasswordError = exports.NotValidEmailError = void 0;
 class NotValidEmailError extends Error {
     constructor() {
         super('Email is not valid');
@@ -85,6 +85,20 @@ class EmptyFolderNameError extends Error {
     }
 }
 exports.EmptyFolderNameError = EmptyFolderNameError;
+class EmptyCustomAuthUsernameError extends Error {
+    constructor() {
+        super('Custom auth username can not be empty');
+        Object.setPrototypeOf(this, EmptyCustomAuthUsernameError.prototype);
+    }
+}
+exports.EmptyCustomAuthUsernameError = EmptyCustomAuthUsernameError;
+class EmptyCustomAuthPasswordError extends Error {
+    constructor() {
+        super('Custom auth password can not be empty');
+        Object.setPrototypeOf(this, EmptyCustomAuthPasswordError.prototype);
+    }
+}
+exports.EmptyCustomAuthPasswordError = EmptyCustomAuthPasswordError;
 class NotValidPortError extends Error {
     constructor() {
         super('Port should be a number between 1 and 65535');
@@ -106,3 +120,17 @@ class NotValidFileError extends Error {
     }
 }
 exports.NotValidFileError = NotValidFileError;
+class NotValidWorkspaceUuidError extends Error {
+    constructor() {
+        super('Workspace UUID is not valid (it must be a valid v4 UUID)');
+        Object.setPrototypeOf(this, NotValidWorkspaceUuidError.prototype);
+    }
+}
+exports.NotValidWorkspaceUuidError = NotValidWorkspaceUuidError;
+class MissingCredentialsWhenUsingAuthError extends Error {
+    constructor() {
+        super('When using custom WebDAV authentication, both username and password must be provided');
+        Object.setPrototypeOf(this, MissingCredentialsWhenUsingAuthError.prototype);
+    }
+}
+exports.MissingCredentialsWhenUsingAuthError = MissingCredentialsWhenUsingAuthError;

package/dist/types/config.types.d.ts

@@ -1,4 +1,5 @@
 export interface ConfigKeys {
+    readonly NODE_ENV: string;
     readonly DRIVE_WEB_URL: string;
     readonly DRIVE_NEW_API_URL: string;
     readonly APP_CRYPTO_SECRET: string;

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

@@ -1,19 +1,20 @@
-import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
-export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
+import { FileMeta, FolderMeta } from '@internxt/sdk/dist/drive/storage/types';
+export type DriveFileItem = Pick<FileMeta, 'uuid' | 'name' | 'bucket' | 'folderUuid' | 'status'> & {
     itemType: 'file';
     size: number;
     createdAt: Date;
     updatedAt: Date;
     creationTime: Date;
     modificationTime: Date;
-    type?: string | null;
+    type: string | null;
+    fileId: string | null;
 };
-export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+export type DriveFolderItem = Pick<FolderMeta, 'uuid' | 'name' | 'bucket'> & {
     itemType: 'folder';
-    encryptedName: string;
-    uuid: string;
     createdAt: Date;
     updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
     status: 'EXISTS' | 'TRASHED';
     parentUuid: string | null;
 };

package/dist/types/network.types.d.ts

@@ -1,7 +1,13 @@
+import { NetworkFacade } from '../services/network/network-facade.service';
 export interface NetworkCredentials {
     user: string;
     pass: string;
 }
+export interface NetworkOptions {
+    networkFacade: NetworkFacade;
+    bucket: string;
+    mnemonic: string;
+}
 export type DownloadProgressCallback = (downloadedBytes: number) => void;
 export type UploadProgressCallback = (uploadedBytes: number) => void;
 export interface NetworkOperationBaseOptions {

package/dist/utils/async.utils.d.ts

@@ -1,3 +1,4 @@
 export declare class AsyncUtils {
-    static sleep(ms: number): Promise<void>;
+    static readonly sleep: (ms: number) => Promise<void>;
+    static readonly withTimeout: <T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string) => Promise<T>;
 }

package/dist/utils/async.utils.js

@@ -2,8 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncUtils = void 0;
 class AsyncUtils {
-    static sleep(ms) {
+    static sleep = (ms) => {
         return new Promise((resolve) => setTimeout(resolve, ms));
-    }
+    };
+    static withTimeout = async (promise, timeoutMs, errorMessage = 'Operation timed out') => {
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error(errorMessage));
+            }, timeoutMs);
+        });
+        return Promise.race([promise, timeoutPromise]).finally(() => {
+            clearTimeout(timeoutId);
+        });
+    };
 }
 exports.AsyncUtils = AsyncUtils;

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

@@ -1,22 +1,24 @@
 import cliProgress from 'cli-progress';
 import { Header } from 'tty-table';
-import { LoginUserDetails, PromptOptions } from '../types/command.types';
-import { NetworkFacade } from '../services/network/network-facade.service';
+import { LoginCredentials, LoginUserDetails, PromptOptions } from '../types/command.types';
+import { NetworkCredentials, NetworkOptions } from '../types/network.types';
+export type LogReporter = (message: string) => void;
 export declare class CLIUtils {
     static readonly clearPreviousLine: (jsonFlag?: boolean) => void;
-    static readonly warning: (reporter: (message: string) => void, message: string) => void;
-    static readonly error: (reporter: (message: string) => void, message: string) => void;
-    static readonly success: (reporter: (message: string) => void, message: string) => void;
-    static readonly log: (reporter: (message: string) => void, message: string) => void;
+    static readonly warning: (reporter: LogReporter, message: string) => void;
+    static readonly error: (reporter: LogReporter, message: string) => void;
+    static readonly success: (reporter: LogReporter, message: string) => void;
+    static readonly log: (reporter: LogReporter, message: string) => void;
     static readonly consoleLog: (message: string) => void;
     static readonly doing: (message: string, jsonFlag?: boolean) => void;
     static readonly done: (jsonFlag?: boolean) => void;
     static readonly failed: (jsonFlag?: boolean) => void;
     static readonly progress: (opts: cliProgress.Options, jsonFlag?: boolean) => cliProgress.SingleBar | undefined;
-    static readonly table: (reporter: (message: string) => void, header: Header[], rows: object[]) => void;
+    static readonly table: (reporter: LogReporter, header: Header[], rows: object[]) => void;
     static readonly generateTableHeaderFromType: <T extends object>() => Header[];
     static readonly CommonFlags: {
         'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly getValueFromFlag: (flag: {
         value?: string;
@@ -32,13 +34,13 @@ export declare class CLIUtils {
         validate: (value: string) => Promise<boolean> | boolean;
         error: Error;
         canBeEmpty?: boolean;
-    }, reporter: (message: string) => void) => Promise<string>;
+    }, reporter: LogReporter) => Promise<string>;
     static readonly getDestinationFolderUuid: ({ destinationFolderUuidFlag, destinationFlagName, nonInteractive, reporter, }: {
         destinationFolderUuidFlag: string | undefined;
         destinationFlagName: string;
         nonInteractive: boolean;
-        reporter: (message: string) => void;
-    }) => Promise<string | undefined>;
+        reporter: LogReporter;
+    }) => Promise<string>;
     private static readonly promptWithAttempts;
     static readonly timer: () => {
         stop: () => number;
@@ -49,14 +51,17 @@ export declare class CLIUtils {
     static readonly catchError: ({ error, logReporter, command, jsonFlag, }: {
         error: Error;
         command?: string;
-        logReporter: (message: string) => void;
+        logReporter: LogReporter;
         jsonFlag?: boolean;
     }) => void;
     static readonly parseEmpty: (input: string) => Promise<string>;
-    static readonly prepareNetwork: ({ jsonFlag, loginUserDetails, }: {
-        jsonFlag?: boolean;
-        loginUserDetails: LoginUserDetails;
-    }) => NetworkFacade;
+    static readonly prepareNetwork: (loginUserDetails: LoginUserDetails) => Promise<NetworkOptions>;
+    static readonly fallbackToRootFolderIdIfEmpty: (folderId: string) => Promise<string>;
+    static readonly getNetworkCreds: (userCredentials: LoginCredentials["user"]) => Promise<{
+        bucket: string;
+        credentials: NetworkCredentials;
+        mnemonic: string;
+    }>;
 }
 export declare class NoFlagProvidedError extends Error {
     constructor(flag: string);

package/dist/utils/cli.utils.js

@@ -15,8 +15,7 @@ const sdk_manager_service_1 = require("../services/sdk-manager.service");
 const inxt_js_1 = require("@internxt/inxt-js");
 const config_service_1 = require("../services/config.service");
 const network_facade_service_1 = require("../services/network/network-facade.service");
-const download_service_1 = require("../services/network/download.service");
-const crypto_service_1 = require("../services/crypto.service");
+const auth_service_1 = require("../services/auth.service");
 class CLIUtils {
     static clearPreviousLine = (jsonFlag) => {
         if (!jsonFlag) {
@@ -77,6 +76,12 @@ class CLIUtils {
             description: 'Prevents the CLI from being interactive. When enabled, the CLI will not request input through the console and will throw errors directly.',
             required: false,
         }),
+        debug: core_1.Flags.boolean({
+            env: 'INXT_DEBUG',
+            helpGroup: 'helper',
+            description: 'Enables debug mode. When enabled, the CLI will print debug messages to the console.',
+            required: false,
+        }),
     };
     static getValueFromFlag = async (flag, command, validation, reporter) => {
         if (flag.value) {
@@ -117,12 +122,7 @@ class CLIUtils {
             error: new command_types_1.NotValidFolderUuidError(),
             canBeEmpty: true,
         }, reporter);
-        if (destinationFolderUuid.trim().length === 0) {
-            return undefined;
-        }
-        else {
-            return destinationFolderUuid;
-        }
+        return destinationFolderUuid;
     };
     static promptWithAttempts = async (prompt, maxAttempts, validation, reporter) => {
         let isValid = false;
@@ -212,22 +212,52 @@ class CLIUtils {
         }
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
-    static prepareNetwork = ({ jsonFlag, loginUserDetails, }) => {
-        CLIUtils.doing('Preparing Network', jsonFlag);
+    static prepareNetwork = async (loginUserDetails) => {
+        const { credentials, mnemonic, bucket } = await this.getNetworkCreds(loginUserDetails);
         const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
-            user: loginUserDetails.bridgeUser,
-            pass: loginUserDetails.userId,
+            user: credentials.user,
+            pass: credentials.pass,
         });
         const environment = new inxt_js_1.Environment({
-            bridgeUser: loginUserDetails.bridgeUser,
-            bridgePass: loginUserDetails.userId,
+            bridgeUser: credentials.user,
+            bridgePass: credentials.pass,
+            encryptionKey: mnemonic,
             bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
-            encryptionKey: loginUserDetails.mnemonic,
             appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
         });
-        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
-        CLIUtils.done(jsonFlag);
-        return networkFacade;
+        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment);
+        return { networkFacade, bucket, mnemonic };
+    };
+    static fallbackToRootFolderIdIfEmpty = async (folderId) => {
+        if (folderId.trim().length === 0) {
+            return await auth_service_1.AuthService.instance.getCurrentRootFolder();
+        }
+        else {
+            return folderId;
+        }
+    };
+    static getNetworkCreds = async (userCredentials) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        if (currentWorkspace) {
+            return {
+                bucket: currentWorkspace.workspaceCredentials.bucket,
+                credentials: {
+                    user: currentWorkspace.workspaceCredentials.credentials.user,
+                    pass: currentWorkspace.workspaceCredentials.credentials.pass,
+                },
+                mnemonic: currentWorkspace.workspaceData.workspaceUser.key,
+            };
+        }
+        else {
+            return {
+                bucket: userCredentials.bucket,
+                credentials: {
+                    user: userCredentials.bridgeUser,
+                    pass: userCredentials.userId,
+                },
+                mnemonic: userCredentials.mnemonic,
+            };
+        }
     };
 }
 exports.CLIUtils = CLIUtils;

package/dist/utils/crypto.utils.d.ts

@@ -1,6 +1,8 @@
 export declare class CryptoUtils {
-    static getAesInit(): {
+    static readonly getAesInit: () => {
         iv: string;
         salt: string;
     };
+    static readonly extendSecret: (secret: Uint8Array, length: number) => Promise<string>;
+    static readonly XORhex: (a: string, b: string) => string;
 }

package/dist/utils/crypto.utils.js

@@ -1,10 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoUtils = void 0;
+const hash_wasm_1 = require("hash-wasm");
 const config_service_1 = require("../services/config.service");
 class CryptoUtils {
-    static getAesInit() {
+    static getAesInit = () => {
         return { iv: config_service_1.ConfigService.instance.get('APP_MAGIC_IV'), salt: config_service_1.ConfigService.instance.get('APP_MAGIC_SALT') };
-    }
+    };
+    static extendSecret = (secret, length) => {
+        return (0, hash_wasm_1.blake3)(secret, length);
+    };
+    static XORhex = (a, b) => {
+        let res = '', i = a.length, j = b.length;
+        if (i != j) {
+            throw new Error('Can XOR only strings with identical length');
+        }
+        while (i-- > 0 && j-- > 0)
+            res = (Number.parseInt(a.charAt(i), 16) ^ Number.parseInt(b.charAt(j), 16)).toString(16) + res;
+        return res;
+    };
 }
 exports.CryptoUtils = CryptoUtils;

package/dist/utils/database.utils.d.ts

@@ -0,0 +1,11 @@
+export declare class DatabaseUtils {
+    static readonly CREATE_BATCH_SIZE = 100;
+    static readonly getFolderByPathGeneric: <T>({ path, parentUuid, onFound, getByParentAndName, }: {
+        path: string;
+        parentUuid: string;
+        onFound: (uuid: string) => Promise<T>;
+        getByParentAndName: (parentUuid: string, name: string) => Promise<{
+            uuid: string;
+        } | null | undefined>;
+    }) => Promise<T | undefined>;
+}

package/dist/utils/database.utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseUtils = void 0;
+class DatabaseUtils {
+    static CREATE_BATCH_SIZE = 100;
+    static getFolderByPathGeneric = async ({ path, parentUuid, onFound, getByParentAndName, }) => {
+        path = path.replace(/^\//, '').replace(/\/$/, '');
+        if (path.trim().length === 0) {
+            return onFound(parentUuid);
+        }
+        const slashIndex = path.indexOf('/');
+        const currentFolder = slashIndex === -1 ? path : path.substring(0, slashIndex);
+        const nextPath = slashIndex === -1 ? '' : path.substring(slashIndex + 1);
+        const folder = await getByParentAndName(parentUuid, currentFolder);
+        if (!folder) {
+            return;
+        }
+        return this.getFolderByPathGeneric({
+            path: nextPath,
+            parentUuid: folder.uuid,
+            onFound,
+            getByParentAndName,
+        });
+    };
+}
+exports.DatabaseUtils = DatabaseUtils;

package/dist/utils/drive.utils.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveUtils = void 0;
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 class DriveUtils {
     static driveFileMetaToItem(fileMeta) {
         return {
             itemType: 'file',
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
-            folderId: fileMeta.folderId,
             folderUuid: fileMeta.folderUuid,
             size: Number(fileMeta.size),
             name: fileMeta.plainName ?? fileMeta.name,
@@ -17,7 +17,6 @@ class DriveUtils {
             creationTime: new Date(fileMeta.creationTime ?? fileMeta.createdAt),
             modificationTime: new Date(fileMeta.modificationTime ?? fileMeta.updatedAt),
             fileId: fileMeta.fileId,
-            id: fileMeta.id,
             type: fileMeta.type,
         };
     }
@@ -25,30 +24,28 @@ class DriveUtils {
         return {
             itemType: 'folder',
             uuid: folderMeta.uuid,
-            id: folderMeta.id,
             bucket: folderMeta.bucket,
-            status: folderMeta.deleted || folderMeta.removed ? 'TRASHED' : 'EXISTS',
+            status: folderMeta.deleted || folderMeta.removed ? types_1.FileStatus.TRASHED : types_1.FileStatus.EXISTS,
             name: folderMeta.plainName ?? folderMeta.name,
-            encryptedName: folderMeta.name,
-            parentId: folderMeta.parentId,
             parentUuid: folderMeta.parentUuid,
             createdAt: new Date(folderMeta.createdAt),
             updatedAt: new Date(folderMeta.updatedAt),
+            creationTime: new Date(folderMeta.creation_time),
+            modificationTime: new Date(folderMeta.creation_time),
         };
     }
     static createFolderResponseToItem(folderResponse) {
         return {
             itemType: 'folder',
             uuid: folderResponse.uuid,
-            id: folderResponse.id,
             bucket: folderResponse.bucket,
-            status: folderResponse.deleted || folderResponse.removed ? 'TRASHED' : 'EXISTS',
+            status: folderResponse.deleted || folderResponse.removed ? types_1.FileStatus.TRASHED : types_1.FileStatus.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),
+            creationTime: new Date(folderResponse.creationTime),
+            modificationTime: new Date(folderResponse.modificationTime),
         };
     }
 }

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

@@ -1,8 +1,8 @@
-export declare function isError(error: unknown): error is Error;
-export declare function isAlreadyExistsError(error: unknown): error is Error;
-export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;
 export declare class ErrorUtils {
-    static report(error: unknown, props?: Record<string, unknown>): void;
+    static readonly isError: (error: unknown) => error is Error;
+    static readonly report: (error: unknown, props?: Record<string, unknown>) => void;
+    static readonly isAlreadyExistsError: (error: unknown) => error is Error;
+    static readonly isFileNotFoundError: (error: unknown) => error is NodeJS.ErrnoException;
 }
 export declare class ConflictError extends Error {
     statusCode: number;

package/dist/utils/errors.utils.js

@@ -1,32 +1,29 @@
 "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;
-exports.isAlreadyExistsError = isAlreadyExistsError;
-exports.isFileNotFoundError = isFileNotFoundError;
 const logger_utils_1 = require("./logger.utils");
-function isError(error) {
-    return typeof Error.isError === 'function'
-        ? Error.isError(error)
-        : error instanceof Error ||
-            (typeof error === 'object' && error !== null && 'message' in error && ('stack' in error || 'name' in error));
-}
-function isAlreadyExistsError(error) {
-    return ((isError(error) && error.message.includes('already exists')) ||
-        (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
-}
-function isFileNotFoundError(error) {
-    return isError(error) && 'code' in error && error.code === 'ENOENT';
-}
 class ErrorUtils {
-    static report(error, props = {}) {
-        if (isError(error)) {
+    static isError = (error) => {
+        return typeof Error.isError === 'function'
+            ? Error.isError(error)
+            : error instanceof Error ||
+                (typeof error === 'object' && error !== null && 'message' in error && ('stack' in error || 'name' in error));
+    };
+    static report = (error, props = {}) => {
+        if (this.isError(error)) {
             logger_utils_1.logger.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
         }
         else {
             logger_utils_1.logger.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
         }
-    }
+    };
+    static isAlreadyExistsError = (error) => {
+        return ((this.isError(error) && error.message.includes('already exists')) ||
+            (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
+    };
+    static isFileNotFoundError = (error) => {
+        return this.isError(error) && 'code' in error && error.code === 'ENOENT';
+    };
 }
 exports.ErrorUtils = ErrorUtils;
 class ConflictError extends Error {

package/dist/utils/format.utils.d.ts

@@ -3,4 +3,5 @@ export declare class FormatUtils {
     static readonly formatDate: (date: string | Date) => string;
     static readonly formatDateForWebDav: (date: string | Date) => string;
     static readonly formatLimit: (limit: number) => string;
+    static readonly capitalizeFirstLetter: (string: string) => string;
 }

package/dist/utils/format.utils.js

@@ -26,5 +26,8 @@ class FormatUtils {
         }
         return result;
     };
+    static capitalizeFirstLetter = (string) => {
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    };
 }
 exports.FormatUtils = FormatUtils;