@internxt/cli 1.6.2 → 1.6.3

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

@@ -0,0 +1,67 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFileModel = void 0;
+const typeorm_1 = require("typeorm");
+let DriveFileModel = class DriveFileModel {
+};
+exports.DriveFileModel = DriveFileModel;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "uuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], DriveFileModel.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], DriveFileModel.prototype, "fileId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "folderUuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "bucket", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'bigint' }),
+    __metadata("design:type", Number)
+], DriveFileModel.prototype, "size", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFileModel.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "creationTime", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFileModel.prototype, "modificationTime", void 0);
+exports.DriveFileModel = DriveFileModel = __decorate([
+    (0, typeorm_1.Entity)('drive_file')
+], DriveFileModel);

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

@@ -0,0 +1,11 @@
+import { DriveFile } from './drive-file.domain';
+import { DriveFileModel } from './drive-file.model';
+export declare class FileRepository {
+    static readonly instance: FileRepository;
+    private readonly fileRepository;
+    createOrUpdate: (files: DriveFileModel[]) => Promise<DriveFile[] | undefined>;
+    updateByUuid: (uuid: string, update: Partial<DriveFileModel>) => Promise<import("typeorm").UpdateResult | undefined>;
+    delete: (uuids: string[]) => Promise<import("typeorm").DeleteResult | undefined>;
+    deleteByParentUuid: (parentUuid: string) => Promise<import("typeorm").DeleteResult | undefined>;
+    getByParentUuidNameAndType: (parentUuid: string, name: string, type: string | null) => Promise<DriveFile | undefined>;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRepository = void 0;
+const typeorm_1 = require("typeorm");
+const database_utils_1 = require("../../../utils/database.utils");
+const errors_utils_1 = require("../../../utils/errors.utils");
+const database_service_1 = require("../database.service");
+const drive_file_domain_1 = require("./drive-file.domain");
+const drive_file_model_1 = require("./drive-file.model");
+class FileRepository {
+    static instance = new FileRepository();
+    fileRepository = database_service_1.DatabaseService.instance.dataSource.getRepository(drive_file_model_1.DriveFileModel);
+    createOrUpdate = async (files) => {
+        try {
+            for (let i = 0; i < files.length; i += database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE) {
+                const chunk = files.slice(i, i + database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE);
+                await this.fileRepository.upsert(chunk, { conflictPaths: ['uuid'] });
+            }
+            return files.map((file) => drive_file_domain_1.DriveFile.build(file));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { createOrUpdate: files });
+        }
+    };
+    updateByUuid = async (uuid, update) => {
+        try {
+            return await this.fileRepository.update({ uuid }, update);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { updateByUuid: uuid });
+        }
+    };
+    delete = async (uuids) => {
+        try {
+            return await this.fileRepository.delete(uuids);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { delete: uuids });
+        }
+    };
+    deleteByParentUuid = async (parentUuid) => {
+        try {
+            return await this.fileRepository.delete({ folderUuid: parentUuid });
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { deleteByParentUuid: parentUuid });
+        }
+    };
+    getByParentUuidNameAndType = async (parentUuid, name, type) => {
+        try {
+            const typeCondition = type ?? (0, typeorm_1.IsNull)();
+            const file = await this.fileRepository.findOneBy({ folderUuid: parentUuid, name, type: typeCondition });
+            if (!file) {
+                return;
+            }
+            return drive_file_domain_1.DriveFile.build(file);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByParentuuidAndName: { parentUuid, name, type } });
+        }
+    };
+}
+exports.FileRepository = FileRepository;

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

@@ -1,11 +1,10 @@
 export interface DriveFolderAttributes {
-    id: number;
-    name: string;
     uuid: string;
+    name: string;
     status: 'EXISTS' | 'TRASHED';
-    relativePath: string;
-    parentId: number | null;
     parentUuid: string | null;
     createdAt: Date;
     updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
 }

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

@@ -1,16 +1,15 @@
 import { DriveFolderItem } from '../../../types/drive.types';
 import { DriveFolderAttributes } from './drive-folder.attributes';
 export declare class DriveFolder implements DriveFolderAttributes {
-    id: number;
     name: string;
     uuid: string;
-    relativePath: string;
-    parentId: number | null;
     parentUuid: string | null;
+    status: DriveFolderAttributes['status'];
     createdAt: Date;
     updatedAt: Date;
-    status: DriveFolderAttributes['status'];
-    constructor({ id, name, uuid, relativePath, parentId, parentUuid, createdAt, updatedAt, status, }: DriveFolderAttributes);
+    creationTime: Date;
+    modificationTime: Date;
+    constructor({ name, uuid, parentUuid, createdAt, updatedAt, status, creationTime, modificationTime, }: DriveFolderAttributes);
     static build(folder: DriveFolderAttributes): DriveFolder;
     toJSON(): DriveFolderAttributes;
     toItem(): DriveFolderItem;

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

@@ -2,54 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFolder = void 0;
 class DriveFolder {
-    id;
     name;
     uuid;
-    relativePath;
-    parentId;
     parentUuid;
+    status;
     createdAt;
     updatedAt;
-    status;
-    constructor({ id, name, uuid, relativePath, parentId, parentUuid, createdAt, updatedAt, status, }) {
-        this.id = id;
+    creationTime;
+    modificationTime;
+    constructor({ name, uuid, parentUuid, createdAt, updatedAt, status, creationTime, modificationTime, }) {
         this.name = name;
         this.uuid = uuid;
-        this.relativePath = relativePath;
-        this.parentId = parentId;
         this.parentUuid = parentUuid;
+        this.status = status;
         this.createdAt = createdAt;
         this.updatedAt = updatedAt;
-        this.status = status;
+        this.creationTime = creationTime;
+        this.modificationTime = modificationTime;
     }
     static build(folder) {
         return new DriveFolder(folder);
     }
     toJSON() {
         return {
-            id: this.id,
             name: this.name,
             uuid: this.uuid,
             status: this.status,
-            relativePath: this.relativePath,
-            parentId: this.parentId,
             parentUuid: this.parentUuid,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
+            creationTime: this.creationTime,
+            modificationTime: this.modificationTime,
         };
     }
     toItem() {
         return {
             itemType: 'folder',
-            id: this.id,
             name: this.name,
             uuid: this.uuid,
             status: this.status,
-            parentId: this.parentId,
             parentUuid: this.parentUuid,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
-            encryptedName: '',
+            creationTime: this.creationTime,
+            modificationTime: this.modificationTime,
             bucket: null,
         };
     }

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

@@ -0,0 +1,11 @@
+import { DriveFolderAttributes } from './drive-folder.attributes';
+export declare class DriveFolderModel implements DriveFolderAttributes {
+    uuid: string;
+    name: string;
+    status: 'EXISTS' | 'TRASHED';
+    parentUuid: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    creationTime: Date;
+    modificationTime: Date;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveFolderModel = void 0;
+const typeorm_1 = require("typeorm");
+let DriveFolderModel = class DriveFolderModel {
+};
+exports.DriveFolderModel = DriveFolderModel;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "uuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", String)
+], DriveFolderModel.prototype, "status", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
+    __metadata("design:type", Object)
+], DriveFolderModel.prototype, "parentUuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "creationTime", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
+    __metadata("design:type", Date)
+], DriveFolderModel.prototype, "modificationTime", void 0);
+exports.DriveFolderModel = DriveFolderModel = __decorate([
+    (0, typeorm_1.Entity)('drive_folder')
+], DriveFolderModel);

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

@@ -0,0 +1,13 @@
+import { DriveFolder } from './drive-folder.domain';
+import { DriveFolderModel } from './drive-folder.model';
+export declare class FolderRepository {
+    static readonly instance: FolderRepository;
+    private readonly folderRepository;
+    getByUuid: (uuid: string) => Promise<DriveFolder | undefined>;
+    getAllByParentUuid: (parentUuid?: string) => Promise<DriveFolder[] | undefined>;
+    getByParentUuidAndName: (parentUuid: string, name: string) => Promise<DriveFolder | undefined>;
+    getByPath: (path: string, parentUuid: string) => Promise<DriveFolder | undefined>;
+    createOrUpdate: (files: DriveFolderModel[]) => Promise<DriveFolder[] | undefined>;
+    updateByUuid: (uuid: string, update: Partial<DriveFolderModel>) => Promise<import("typeorm").UpdateResult | undefined>;
+    delete: (uuids: string[]) => Promise<import("typeorm").DeleteResult | undefined>;
+}

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FolderRepository = void 0;
+const errors_utils_1 = require("../../../utils/errors.utils");
+const database_service_1 = require("../database.service");
+const drive_folder_domain_1 = require("./drive-folder.domain");
+const drive_folder_model_1 = require("./drive-folder.model");
+const database_utils_1 = require("../../../utils/database.utils");
+class FolderRepository {
+    static instance = new FolderRepository();
+    folderRepository = database_service_1.DatabaseService.instance.dataSource.getRepository(drive_folder_model_1.DriveFolderModel);
+    getByUuid = async (uuid) => {
+        try {
+            const folder = await this.folderRepository.findOneBy({ uuid });
+            if (!folder) {
+                return;
+            }
+            return drive_folder_domain_1.DriveFolder.build(folder);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByUuid: uuid });
+        }
+    };
+    getAllByParentUuid = async (parentUuid) => {
+        try {
+            const folders = await this.folderRepository.findBy({ parentUuid });
+            if (!folders) {
+                return;
+            }
+            return folders.map((folder) => drive_folder_domain_1.DriveFolder.build(folder));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getAllByParentUuid: parentUuid });
+        }
+    };
+    getByParentUuidAndName = async (parentUuid, name) => {
+        try {
+            const folder = await this.folderRepository.findOneBy({ parentUuid, name });
+            if (!folder) {
+                return;
+            }
+            return drive_folder_domain_1.DriveFolder.build(folder);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByParentuuidAndName: { parentUuid, name } });
+        }
+    };
+    getByPath = async (path, parentUuid) => {
+        try {
+            const onFound = async (uuid) => {
+                const folder = await this.folderRepository.findOneBy({ uuid });
+                if (!folder) {
+                    return;
+                }
+                return drive_folder_domain_1.DriveFolder.build(folder);
+            };
+            return database_utils_1.DatabaseUtils.getFolderByPathGeneric({
+                path,
+                parentUuid,
+                onFound,
+                getByParentAndName: this.getByParentUuidAndName.bind(this),
+            });
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByPath: path });
+        }
+    };
+    createOrUpdate = async (files) => {
+        if (files.length === 0)
+            return;
+        try {
+            for (let i = 0; i < files.length; i += database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE) {
+                const chunk = files.slice(i, i + database_utils_1.DatabaseUtils.CREATE_BATCH_SIZE);
+                await this.folderRepository.upsert(chunk, { conflictPaths: ['uuid'] });
+            }
+            return files.map((file) => drive_folder_domain_1.DriveFolder.build(file));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { createOrUpdate: files });
+        }
+    };
+    updateByUuid = async (uuid, update) => {
+        try {
+            return await this.folderRepository.update({ uuid }, update);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { updateByUuid: uuid });
+        }
+    };
+    delete = async (uuids) => {
+        try {
+            return await this.folderRepository.delete(uuids);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { delete: uuids });
+        }
+    };
+}
+exports.FolderRepository = FolderRepository;

package/dist/services/drive/drive-file.service.d.ts

@@ -3,12 +3,14 @@ import { DriveFileItem } from '../../types/drive.types';
 export declare class DriveFileService {
     static readonly instance: DriveFileService;
     createFile: (payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
+    private createDriveFileEntry;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
     moveFile: (uuid: string, payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
     renameFile: (fileUuid: string, payload: {
         plainName?: string;
         type?: string | null;
     }) => Promise<void>;
+    getByParentUuidAndName: (parentUuid: string, name: string, type: string | null) => Promise<DriveFileItem>;
     getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;
     createThumbnail: (payload: StorageTypes.CreateThumbnailEntryPayload) => Promise<StorageTypes.Thumbnail>;
 }

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

@@ -1,49 +1,105 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFileService = void 0;
+const drive_1 = require("@internxt/sdk/dist/drive");
 const sdk_manager_service_1 = require("../sdk-manager.service");
 const drive_utils_1 = require("../../utils/drive.utils");
+const auth_service_1 = require("../auth.service");
+const drive_file_repository_1 = require("../database/drive-file/drive-file.repository");
+const drive_folder_service_1 = require("./drive-folder.service");
+const errors_utils_1 = require("../../utils/errors.utils");
+const path_utils_1 = require("../../utils/path.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 class DriveFileService {
     static instance = new DriveFileService();
     createFile = async (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const driveFile = await storageClient.createFileEntryByUuid(payload);
-        return {
+        const driveFile = await this.createDriveFileEntry(payload);
+        const driveFileItem = {
             itemType: 'file',
             name: payload.plainName,
-            id: driveFile.id,
             uuid: driveFile.uuid,
             size: driveFile.size,
             bucket: driveFile.bucket,
             createdAt: new Date(driveFile.createdAt),
             updatedAt: new Date(driveFile.updatedAt),
-            fileId: driveFile.fileId,
-            type: driveFile.type,
+            fileId: driveFile.fileId ?? null,
+            type: driveFile.type ?? null,
             status: driveFile.status,
-            folderId: driveFile.folderId,
             folderUuid: driveFile.folderUuid,
             creationTime: new Date(driveFile.creationTime ?? driveFile.createdAt),
             modificationTime: new Date(driveFile.modificationTime ?? driveFile.updatedAt),
         };
+        await drive_file_repository_1.FileRepository.instance.createOrUpdate([driveFileItem]);
+        return driveFileItem;
+    };
+    createDriveFileEntry = async (payload) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        if (currentWorkspace) {
+            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
+            return workspaceClient.createFileEntry({
+                name: payload.plainName,
+                plainName: payload.plainName,
+                bucket: payload.bucket,
+                fileId: payload.fileId ?? '',
+                encryptVersion: drive_1.StorageTypes.EncryptionVersion.Aes03,
+                folderUuid: payload.folderUuid,
+                size: payload.size,
+                type: payload.type ?? '',
+                modificationTime: payload.modificationTime ?? new Date().toISOString(),
+                date: payload.date ?? new Date().toISOString(),
+            }, currentWorkspace.workspaceCredentials.id);
+        }
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return storageClient.createFileEntryByUuid(payload);
     };
     getFileMetadata = async (uuid) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const [getFileMetadata] = storageClient.getFile(uuid);
         const fileMetadata = await getFileMetadata;
-        return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
+        if (fileMetadata?.status !== types_1.FileStatus.EXISTS) {
+            throw new errors_utils_1.NotFoundError(`File with uuid ${uuid} not found`);
+        }
+        const driveFileItem = drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
+        await drive_file_repository_1.FileRepository.instance.createOrUpdate([driveFileItem]);
+        return driveFileItem;
     };
-    moveFile = (uuid, payload) => {
+    moveFile = async (uuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.moveFileByUuid(uuid, payload);
+        const fileMeta = await storageClient.moveFileByUuid(uuid, payload);
+        const driveFileItem = drive_utils_1.DriveUtils.driveFileMetaToItem(fileMeta);
+        await drive_file_repository_1.FileRepository.instance.createOrUpdate([driveFileItem]);
+        return fileMeta;
     };
-    renameFile = (fileUuid, payload) => {
+    renameFile = async (fileUuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.updateFileMetaByUUID(fileUuid, payload);
+        await storageClient.updateFileMetaByUUID(fileUuid, payload);
+        await drive_file_repository_1.FileRepository.instance.updateByUuid(fileUuid, { name: payload.plainName, type: payload.type });
+    };
+    getByParentUuidAndName = async (parentUuid, name, type) => {
+        const subFiles = await drive_folder_service_1.DriveFolderService.instance.getFolderSubfiles(parentUuid);
+        const fileMeta = subFiles.find((file) => (file.plainName === name || file.name === name) && (file.type ?? null) === type);
+        if (fileMeta?.status !== types_1.FileStatus.EXISTS) {
+            throw new errors_utils_1.NotFoundError('File not found');
+        }
+        return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMeta);
     };
     getFileMetadataByPath = async (path) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const fileMetadata = await storageClient.getFileByPath(encodeURIComponent(path));
-        return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
+        const { fileName, fileType, folderPath } = path_utils_1.PathUtils.getPathFileData(path);
+        const parentFolder = await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(folderPath);
+        const localFileDB = await drive_file_repository_1.FileRepository.instance.getByParentUuidNameAndType(parentFolder.uuid, fileName, fileType);
+        if (localFileDB) {
+            try {
+                const file = await this.getFileMetadata(localFileDB.uuid);
+                if (file) {
+                    return file;
+                }
+            }
+            catch {
+                logger_utils_1.logger.error('File not found when getting file by path on local DB', { path });
+            }
+        }
+        return this.getByParentUuidAndName(parentFolder.uuid, fileName, fileType);
     };
     createThumbnail = (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

package/dist/services/drive/drive-folder.service.d.ts

@@ -1,3 +1,4 @@
+import { FetchPaginatedFile, FetchPaginatedFolder } from '@internxt/sdk/dist/drive/storage/types';
 import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { DriveFolderItem } from '../../types/drive.types';
 import { RequestCanceler } from '@internxt/sdk/dist/shared/http/types';
@@ -47,13 +48,17 @@ export declare class DriveFolderService {
             status: "EXISTS" | "TRASHED" | "DELETED";
         }[];
     }>;
+    getFolderSubfolders: (folderUuid: string) => Promise<FetchPaginatedFolder[]>;
+    getFolderSubfiles: (folderUuid: string) => Promise<FetchPaginatedFile[]>;
     private readonly getAllSubfolders;
     private readonly getAllSubfiles;
     moveFolder: (uuid: string, payload: StorageTypes.MoveFolderUuidPayload) => Promise<StorageTypes.FolderMeta>;
-    createFolder(payload: StorageTypes.CreateFolderByUuidPayload): [Promise<StorageTypes.CreateFolderResponse>, RequestCanceler];
+    createFolder: (payload: StorageTypes.CreateFolderByUuidPayload) => Promise<[Promise<StorageTypes.CreateFolderResponse>, RequestCanceler]>;
     renameFolder: (payload: {
         folderUuid: string;
         name: string;
     }) => Promise<void>;
+    getByParentUuidAndName: (parentUuid: string, name: string) => Promise<DriveFolderItem>;
+    getByPath: (path: string, parentUuid: string) => Promise<DriveFolderItem>;
     getFolderMetadataByPath: (path: string) => Promise<DriveFolderItem>;
 }