@cooperation/vc-storage 1.0.33 → 1.0.40

package/dist/models/GoogleDriveStorage.js

@@ -2,21 +2,25 @@
  * @class GoogleDriveStorage
  * @description Class to interact with Google Drive API
  * @param accessToken - Access token to authenticate with Google Drive API
- * @method createFolder - Create a new folder in Google Drive
- * @method save - Save data to Google Drive
- * @method addCommentToFile - Add a comment to a file in Google Drive
- * @method addCommenterRoleToFile - Add commenter role to a file in Google Drive
+ * @method saveFile - Save a file to Google Drive
  * @method retrieve - Retrieve a file from Google Drive
- * @method findFolders - Find folders in Google Drive
- * @method findLastFile - Find the last file in a folder
- * @method getAllVCs - Get all verifiable credentials from Google Drive
- * @method getAllSessions - Get all sessions from Google Drive
+ * @method createFolder - Create a new folder in Google Drive
+ * @method getOrCreateMediaFolder - Get the ID of the MEDIAs folder
+ * @method uploadBinaryFile - Upload a binary file to Google Drive
+ * @method updateFileData - Update the data of a file
+ * @method updateRelationsFile - Update the relations file
  * @method delete - Delete a file from Google Drive
+ * @method checkEmailExists - Check if an email VC exists and return its content
+ * @method findFolders - Find folders in Google Drive
+ * @method findFolderFiles - Find files in a folder
  */
 export class GoogleDriveStorage {
     accessToken;
-    folderCache = {};
-    fileIdsCache = null;
+    static folderCache = {};
+    static fileIdsCache = null;
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
     async updateFileIdsJson(newFileId) {
         const constructUrl = () => {
             const baseUrl = 'https://www.googleapis.com/drive/v3/files';
@@ -29,28 +33,28 @@ export class GoogleDriveStorage {
         };
         try {
             // ✅ Fetch `file_ids.json` ID once per session (cached)
-            if (!this.fileIdsCache) {
+            if (!GoogleDriveStorage.fileIdsCache) {
                 const existingFile = await this.fetcher({
                     method: 'GET',
                     headers: {},
                     url: constructUrl(),
                 });
                 if (existingFile.files.length > 0) {
-                    this.fileIdsCache = existingFile.files[0].id;
+                    GoogleDriveStorage.fileIdsCache = existingFile.files[0].id;
                 }
                 else {
                     console.log('No existing file_ids.json found, creating a new one.');
-                    this.fileIdsCache = null;
+                    GoogleDriveStorage.fileIdsCache = null;
                 }
             }
             let existingFileIds = [];
             // ✅ Fetch existing file IDs **only if `file_ids.json` exists**
-            if (this.fileIdsCache) {
+            if (GoogleDriveStorage.fileIdsCache) {
                 try {
                     const fileContent = await this.fetcher({
                         method: 'GET',
                         headers: {},
-                        url: `https://www.googleapis.com/drive/v3/files/${this.fileIdsCache}?alt=media`,
+                        url: `https://www.googleapis.com/drive/v3/files/${GoogleDriveStorage.fileIdsCache}?alt=media`,
                     });
                     existingFileIds = fileContent;
                 }
@@ -60,16 +64,13 @@ export class GoogleDriveStorage {
             }
             // ✅ Append the new file ID to the list
             existingFileIds.push(newFileId);
-            console.log('File ID saved to appDataFolder.', this.fileIdsCache);
+            console.log('File ID saved to appDataFolder.', GoogleDriveStorage.fileIdsCache);
         }
         catch (error) {
             console.error('Error updating file_ids.json:', error.message);
             throw error;
         }
     }
-    constructor(accessToken) {
-        this.accessToken = accessToken;
-    }
     async fetcher({ method, headers, body, url }) {
         try {
             const res = await fetch(url, {
@@ -120,6 +121,43 @@ export class GoogleDriveStorage {
         });
         return result.files || [];
     }
+    async getOrCreateMediaFolder() {
+        if (GoogleDriveStorage.folderCache['MEDIAs']) {
+            return GoogleDriveStorage.folderCache['MEDIAs'];
+        }
+        const rootFolders = await this.findFolders();
+        let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
+        if (!credentialsFolder) {
+            credentialsFolder = await this.createFolder({ folderName: 'Credentials', parentFolderId: 'root' });
+        }
+        const subfolders = await this.findFolders(credentialsFolder.id);
+        let mediasFolder = subfolders.find((f) => f.name === 'MEDIAs');
+        if (!mediasFolder) {
+            mediasFolder = await this.createFolder({ folderName: 'MEDIAs', parentFolderId: credentialsFolder.id });
+        }
+        GoogleDriveStorage.folderCache['MEDIAs'] = mediasFolder.id;
+        return mediasFolder.id;
+    }
+    async findFolderFiles(folderId) {
+        if (!folderId)
+            throw new Error('Folder ID is required');
+        const files = await this.searchFiles(`'${folderId}' in parents`);
+        if (files.length === 0) {
+            console.log('No files found in the folder.');
+            return [];
+        }
+        const filesWithContent = await Promise.all(files.map(async (file) => {
+            try {
+                const content = await this.getFileContent(file.id);
+                return { ...file, content };
+            }
+            catch (error) {
+                console.error(`Error fetching content for file "${file.name}" (ID: ${file.id}):`, error);
+                return { ...file, content: null };
+            }
+        }));
+        return filesWithContent;
+    }
     async createFolder({ folderName, parentFolderId }) {
         if (!parentFolderId) {
             throw new Error(`Parent folder ID must be provided when creating folder "${folderName}".`);
@@ -143,42 +181,29 @@ export class GoogleDriveStorage {
             body: JSON.stringify({ role: 'reader', type: 'anyone' }),
         });
         // Invalidate cache for this parent folder
-        if (this.folderCache[parentFolderId]) {
-            delete this.folderCache[parentFolderId];
+        if (GoogleDriveStorage.folderCache[parentFolderId]) {
+            delete GoogleDriveStorage.folderCache[parentFolderId];
         }
         // Also clear 'root' cache if parent is root
-        if (parentFolderId === 'root' && this.folderCache['root']) {
-            delete this.folderCache['root'];
+        if (parentFolderId === 'root' && GoogleDriveStorage.folderCache['root']) {
+            delete GoogleDriveStorage.folderCache['root'];
         }
         return folder;
     }
+    /**
+     * Get the ID of the MEDIAs folder (public wrapper for getOrCreateMediaFolder)
+     * @returns The folder ID for the MEDIAs folder
+     */
     async getMediaFolderId() {
-        if (this.folderCache['MEDIAs']) {
-            return this.folderCache['MEDIAs'];
-        }
-        const rootFolders = await this.findFolders();
-        let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
-        if (!credentialsFolder) {
-            credentialsFolder = await this.createFolder({ folderName: 'Credentials', parentFolderId: 'root' });
-        }
-        const credentialsFolderId = credentialsFolder.id;
-        const subfolders = await this.findFolders(credentialsFolder.id);
-        let mediasFolder = subfolders.find((f) => f.name === 'MEDIAs');
-        if (!mediasFolder) {
-            mediasFolder = await this.createFolder({ folderName: 'MEDIAs', parentFolderId: credentialsFolderId });
-        }
-        const mediasFolderId = mediasFolder.id;
-        this.folderCache['MEDIAs'] = mediasFolderId;
-        return mediasFolderId;
+        return await this.getOrCreateMediaFolder();
     }
     async uploadBinaryFile({ file }) {
         try {
-            const accessToken = this.accessToken; // Ensure access token is available
+            const accessToken = this.accessToken;
             if (!accessToken) {
                 throw new Error('Missing Google OAuth access token.');
             }
-            const folderId = await this.getMediaFolderId(); // Ensure folderId is correct
-            // ✅ Correct metadata for Google Drive API
+            const folderId = await this.getOrCreateMediaFolder();
             const metadata = {
                 name: file.name,
                 mimeType: file.type,
@@ -209,14 +234,20 @@ export class GoogleDriveStorage {
             throw error;
         }
     }
-    async saveFile({ data, folderId }) {
+    async saveFile({ data, folderId, fileId }) {
         console.log('🚀 ~ GoogleDriveStorage ~ saveFile ~ data:', data);
         try {
+            // If fileId is provided, update the existing file instead of creating a new one
+            if (fileId) {
+                console.log(`Updating existing file with ID: ${fileId}`);
+                return await this.updateFileContent({ fileId, data });
+            }
+            // For new files, folderId is required
             if (!folderId) {
-                throw new Error('Folder ID is required to save a file.');
+                throw new Error('Folder ID is required to save a new file.');
             }
             const fileMetadata = {
-                name: data.fileName || data.name + '.json' || data.credentialSubject.person.name.formattedName + '.json' || 'Untitled file.json',
+                name: data.fileName || data.name + '.json' || data.credentialSubject?.person?.name?.formattedName + '.json' || 'Untitled file.json',
                 parents: [folderId],
                 mimeType: data.mimeType || 'application/json',
             };
@@ -248,11 +279,6 @@ export class GoogleDriveStorage {
             throw error;
         }
     }
-    /**
-     * Get file from google drive by id
-     * @param id
-     * @returns file content
-     */
     async retrieve(id) {
         const dataUrl = `https://www.googleapis.com/drive/v3/files/${id}?alt=media`;
         try {
@@ -293,63 +319,53 @@ export class GoogleDriveStorage {
             return null;
         }
     }
-    /**
-     * Get folder by folderId, if folderId == null you will have them all
-     * @param folderId [Optional]
-     * @returns
-     */
     async findFolders(folderId) {
         const cacheKey = folderId || 'root';
-        if (this.folderCache[cacheKey]) {
-            return this.folderCache[cacheKey];
+        if (GoogleDriveStorage.folderCache[cacheKey]) {
+            return GoogleDriveStorage.folderCache[cacheKey];
         }
         const query = folderId
             ? `'${folderId}' in parents and mimeType='application/vnd.google-apps.folder'`
             : `'root' in parents and mimeType='application/vnd.google-apps.folder'`;
         const folders = await this.searchFiles(query);
-        this.folderCache[cacheKey] = folders;
+        GoogleDriveStorage.folderCache[cacheKey] = folders;
         return folders;
     }
-    /**
-     * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
-     * @param type
-     * @returns
-     */
     async getAllFilesByType(type) {
         try {
-            if (!this.folderCache['Credentials']) {
+            if (!GoogleDriveStorage.folderCache['Credentials']) {
                 const rootFolders = await this.findFolders();
-                this.folderCache['Credentials'] = rootFolders;
+                GoogleDriveStorage.folderCache['Credentials'] = rootFolders;
             }
-            const credentialsFolder = this.folderCache['Credentials'].find((f) => f.name === 'Credentials');
+            const credentialsFolder = GoogleDriveStorage.folderCache['Credentials'].find((f) => f.name === 'Credentials');
             if (!credentialsFolder) {
                 console.error('Credentials folder not found.');
                 return [];
             }
             if (type === 'VCs') {
-                if (!this.folderCache['VCs']) {
+                if (!GoogleDriveStorage.folderCache['VCs']) {
                     const vcSubfolder = await this.findFolders(credentialsFolder.id);
                     const vcsFolder = vcSubfolder.find((f) => f.name === 'VCs');
                     const vcSubFolders = await this.findFolders(vcsFolder.id);
-                    this.folderCache['VCs'] = vcSubFolders.filter((folder) => folder.name.startsWith('VC-'));
+                    GoogleDriveStorage.folderCache['VCs'] = vcSubFolders.filter((folder) => folder.name.startsWith('VC-'));
                 }
-                const vcSubfolders = this.folderCache['VCs'];
+                const vcSubfolders = GoogleDriveStorage.folderCache['VCs'];
                 if (!vcSubfolders.length) {
                     console.error(`No subfolders found for type: ${type}`);
                     return [];
                 }
-                const allFilesNested = await Promise.all(vcSubfolders.map(async (folder) => await this.findFilesUnderFolder(folder.id)));
+                const allFilesNested = await Promise.all(vcSubfolders.map(async (folder) => await this.findFolderFiles(folder.id)));
                 const allVcJsonFiles = allFilesNested.flat().filter((file) => file.mimeType === 'application/json');
                 const fileContentsResults = await Promise.allSettled(allVcJsonFiles.map((file) => this.retrieve(file.id)));
                 const validFileContents = fileContentsResults.filter((result) => result.status === 'fulfilled').map((result) => result.value);
                 return validFileContents.filter((file) => file.data.fileName !== 'RELATIONS');
             }
-            if (!this.folderCache[type]) {
+            if (!GoogleDriveStorage.folderCache[type]) {
                 const subfolders = await this.findFolders(credentialsFolder.id);
                 const targetFolder = subfolders.find((f) => f.name === type);
-                this.folderCache[type] = targetFolder ? targetFolder.id : null;
+                GoogleDriveStorage.folderCache[type] = targetFolder ? targetFolder.id : null;
             }
-            const targetFolderId = this.folderCache[type];
+            const targetFolderId = GoogleDriveStorage.folderCache[type];
             if (!targetFolderId) {
                 console.error(`Folder for type ${type} not found.`);
                 return [];
@@ -369,70 +385,52 @@ export class GoogleDriveStorage {
             return [];
         }
     }
-    /**
-     * Update the name of a file in Google Drive
-     * @param fileId - The ID of the file to update
-     * @param newFileName - The new name for the file
-     * @returns The updated file metadata, including the new name
-     */
-    async updateFileName(fileId, newFileName) {
+    async updateFileData(fileId, data) {
         try {
-            const metadata = { name: newFileName };
+            const updateUrl = `https://www.googleapis.com/drive/v3/files/${fileId}`;
             const updatedFile = await this.fetcher({
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(metadata),
-                url: `https://www.googleapis.com/drive/v3/files/${fileId}`,
+                body: JSON.stringify({ name: data.fileName }),
+                url: updateUrl,
             });
-            console.log('File name updated successfully:', updatedFile.name);
+            console.log('✅ File renamed successfully:', updatedFile);
             return updatedFile;
         }
         catch (error) {
-            console.error('Error updating file name:', error.message);
             throw error;
         }
     }
-    async findFileByName(name) {
-        const rootFolders = await this.findFolders();
-        const credentialsFolderId = rootFolders.find((f) => f.name === 'Credentials')?.id;
-        if (!credentialsFolderId)
-            throw new Error('Credentials folder not found');
-        const files = await this.searchFiles(`'${credentialsFolderId}' in parents and name='${name}'`);
-        return files[0];
-    }
-    async findFilesUnderFolder(folderId) {
-        if (!folderId)
-            throw new Error('Folder ID is required');
-        const files = await this.searchFiles(`'${folderId}' in parents`);
-        if (files.length === 0) {
-            console.log('No files found in the folder.');
-            return [];
-        }
-        const filesWithContent = await Promise.all(files.map(async (file) => {
-            try {
-                const content = await this.getFileContent(file.id);
-                return { ...file, content };
-            }
-            catch (error) {
-                console.error(`Error fetching content for file "${file.name}" (ID: ${file.id}):`, error);
-                return { ...file, content: null };
-            }
-        }));
-        return filesWithContent;
-    }
-    async updateFileData(fileId, data) {
+    /**
+     * Update the content of an existing file in Google Drive
+     * @param fileId - The ID of the file to update
+     * @param data - The new content for the file
+     * @returns The updated file metadata
+     */
+    async updateFileContent({ fileId, data }) {
         try {
-            const updateUrl = `https://www.googleapis.com/drive/v3/files/${fileId}`;
-            const updatedFile = await this.fetcher({
+            if (!fileId) {
+                throw new Error('File ID is required to update a file.');
+            }
+            // Convert data to JSON blob
+            const fileBlob = new Blob([JSON.stringify(data)], { type: 'application/json' });
+            // Update the file content using media upload
+            // Note: When using uploadType=media, the response is the updated file resource
+            const response = await this.fetcher({
                 method: 'PATCH',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ name: data.fileName }),
-                url: updateUrl,
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: fileBlob,
+                url: `https://www.googleapis.com/upload/drive/v3/files/${fileId}?uploadType=media`,
             });
-            console.log('✅ File renamed successfully:', updatedFile);
-            return updatedFile;
+            console.log(`✅ File content updated successfully: ${fileId}`);
+            // Return a consistent response format with id and data
+            // The response from media upload might be the file metadata or empty
+            return { id: fileId, data, ...response };
         }
         catch (error) {
+            console.error('Error updating file content:', error);
             throw error;
         }
     }
@@ -460,12 +458,10 @@ export class GoogleDriveStorage {
         return updateResponse;
     }
     async createRelationsFile({ vcFolderId }) {
-        const files = await this.findFilesUnderFolder(vcFolderId);
+        const files = await this.findFolderFiles(vcFolderId);
         const vcFile = files.find((file) => file.name === 'VC');
         const vcContent = await this.getFileContent(vcFile.id);
-        console.log('🚀 ~ GoogleDriveStorage ~ createRelationsFile ~ vcContent:', vcContent);
         const subject = JSON.parse(vcContent.body).credentialSubject;
-        console.log('🚀 ~ GoogleDriveStorage ~ createRelationsFile ~ subject:', subject);
         const relationsFile = await this.saveFile({
             data: {
                 fileName: 'RELATIONS',
@@ -483,66 +479,6 @@ export class GoogleDriveStorage {
         await this.updateFileIdsJson(relationsFile.id);
         return relationsFile;
     }
-    async updateResumeRelation({ authorFolderId, draftFileId, signedFileId, }) {
-        try {
-            const relationFileName = 'relations.json';
-            // Step 1: Check if `relations.json` exists in RESUMES_AUTHOR/
-            const existingRelationFiles = await this.searchFiles(`name='${relationFileName}' and '${authorFolderId}' in parents`);
-            let relationFileId = null;
-            let existingRelations = {};
-            if (existingRelationFiles.length > 0) {
-                relationFileId = existingRelationFiles[0].id;
-                existingRelations = await this.getFileContent(relationFileId);
-            }
-            else {
-                console.log('relations.json does not exist. Will create a new one.');
-            }
-            // Step 2: Update relations object
-            existingRelations[draftFileId] = signedFileId;
-            // Step 3: Create or update the file on Drive
-            const fileBlob = new Blob([JSON.stringify(existingRelations, null, 2)], {
-                type: 'application/json',
-            });
-            const formData = new FormData();
-            const metadata = {
-                name: relationFileName,
-                parents: [authorFolderId],
-                mimeType: 'application/json',
-            };
-            formData.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
-            formData.append('file', fileBlob);
-            let uploadedFile;
-            if (relationFileId) {
-                // Update existing file
-                uploadedFile = await this.fetcher({
-                    method: 'PATCH',
-                    headers: {},
-                    body: formData,
-                    url: `https://www.googleapis.com/upload/drive/v3/files/${relationFileId}?uploadType=multipart&fields=id,parents`,
-                });
-            }
-            else {
-                // Create new file
-                uploadedFile = await this.fetcher({
-                    method: 'POST',
-                    headers: {},
-                    body: formData,
-                    url: `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,parents`,
-                });
-            }
-            console.log(`✅ Resume relation updated. File ID: ${uploadedFile.id}`);
-            return uploadedFile;
-        }
-        catch (error) {
-            console.error('❌ Failed to update resume relation:', error);
-            throw error;
-        }
-    }
-    /**
-     * Delete file by id
-     * @param id
-     * @returns
-     */
     async delete(id) {
         try {
             const response = await this.fetcher({
@@ -558,94 +494,6 @@ export class GoogleDriveStorage {
             return null;
         }
     }
-    async update(fileId, data) {
-        const metadata = {
-            name: data.fileName || 'resume.json',
-            mimeType: 'application/json',
-        };
-        const uploadUrl = `https://www.googleapis.com/upload/drive/v3/files/${fileId}?uploadType=multipart`;
-        const formData = new FormData();
-        formData.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
-        formData.append('file', new Blob([JSON.stringify(data.body)], { type: 'application/json' }));
-        try {
-            const response = await this.fetcher({
-                method: 'PATCH',
-                headers: {},
-                body: formData,
-                url: `${uploadUrl}&fields=id,name,mimeType`,
-            });
-            console.log('✅ File updated successfully:', response);
-            return response;
-        }
-        catch (error) {
-            console.error('❌ Error updating Google Drive file:', error);
-            throw error;
-        }
-    }
-    async getFileIdsFromAppDataFolder() {
-        try {
-            const constructUrl = () => {
-                const baseUrl = 'https://www.googleapis.com/drive/v3/files';
-                const queryParams = new URLSearchParams({
-                    spaces: 'appDataFolder',
-                    q: "name='file_ids.json'",
-                    fields: 'files(id)',
-                });
-                return `${baseUrl}?${queryParams.toString()}`;
-            };
-            // Step 1: Search for the file_ids.json file in the appDataFolder
-            const response = await this.fetcher({
-                method: 'GET',
-                headers: {},
-                url: constructUrl(),
-            });
-            console.log(':  GoogleDriveStorage  getFileIdsFromAppDataFolder  response', response);
-            // Step 2: Check if the file exists
-            if (!response.files || response.files.length === 0) {
-                console.log('No file_ids.json found in appDataFolder.');
-                return [];
-            }
-            // Step 3: Get the file ID of file_ids.json
-            const fileId = response.files[0].id;
-            console.log(':  GoogleDriveStorage  getFileIdsFromAppDataFolder  fileId', fileId);
-            // Step 4: Fetch the content of file_ids.json
-            const fileContent = await this.fetcher({
-                method: 'GET',
-                headers: {},
-                url: `https://www.googleapis.com/drive/v3/files/${fileId}?alt=media`,
-            });
-            console.log(':  GoogleDriveStorage  getFileIdsFromAppDataFolder  fileContent', fileContent);
-            // Step 5: Parse the file content (array of file IDs)
-            const fileIds = fileContent;
-            console.log(':  GoogleDriveStorage  getFileIdsFromAppDataFolder  fileIds', fileIds);
-            return fileIds;
-        }
-        catch (error) {
-            console.error('Error fetching file IDs from appDataFolder:', error.message);
-            return [];
-        }
-    }
-    async getAllFilesData() {
-        try {
-            // Step 1: Get the file IDs from appDataFolder
-            const fileIds = await this.getFileIdsFromAppDataFolder();
-            if (fileIds.length === 0) {
-                console.log('No files found.');
-                return [];
-            }
-            // Step 2: Return the array of file IDs
-            return fileIds;
-        }
-        catch (error) {
-            console.error('Error fetching all files data:', error.message);
-            return [];
-        }
-    }
-    /**
-     * Check if an email VC exists and return its content
-     * @param email - The email address to check
-     * @returns {Promise<{data: any, id: string} | null>} - The email VC content and ID if exists, null otherwise
-     */
     async checkEmailExists(email) {
         try {
             // Get root folders

package/dist/models/Resume.js

@@ -61,15 +61,27 @@ export class StorageHandler {
         if (!folder) {
             throw new Error(`${folderName} folder not found`);
         }
-        return this.storage.findFilesUnderFolder(folder.id);
+        return this.storage.findFolderFiles(folder.id);
     }
 }
 export class Resume extends StorageHandler {
     constructor(storage) {
         super(storage);
     }
-    async saveResume({ resume, type }) {
+    async saveResume({ resume, type, id }) {
         try {
+            // If an ID is provided, update the existing resume
+            if (id) {
+                console.log(`🔄 Updating existing ${type} resume with ID: ${id}`);
+                // Update the file content directly
+                const updatedResume = await this.storage.updateFileContent({
+                    fileId: id,
+                    data: resume
+                });
+                // Return the updated resume with its ID
+                return { ...updatedResume, id };
+            }
+            // For new resumes, create folders and save as before
             let rootFolder = await this.getOrCreateFolder(resumeFolderTypes.root, 'root');
             console.log('🚀 ~ Resume ~ saveResume ~ rootFolder:', rootFolder);
             // Get or create the subfolder
@@ -106,7 +118,7 @@ export class Resume extends StorageHandler {
             // Find or create the signed resumes folder
             const signedFolder = await this.getOrCreateFolder(resumeFolderTypes.signed, rootFolder.id);
             // Retrieve all files from the signed folder
-            const files = await this.storage.findFilesUnderFolder(signedFolder.id);
+            const files = await this.storage.findFolderFiles(signedFolder.id);
             return files;
         }
         catch (error) {
@@ -120,7 +132,7 @@ export class Resume extends StorageHandler {
             // Find or create the non-signed resumes folder
             const nonSignedFolder = await this.getOrCreateFolder(resumeFolderTypes.nonSigned, rootFolder.id);
             // Retrieve all files from the non-signed folder
-            const files = await this.storage.findFilesUnderFolder(nonSignedFolder.id);
+            const files = await this.storage.findFolderFiles(nonSignedFolder.id);
             return files;
         }
         catch (error) {