@cooperation/vc-storage 1.0.22 → 1.0.24

package/dist/models/GoogleDriveStorage.js

@@ -15,6 +15,58 @@
  */
 export class GoogleDriveStorage {
     accessToken;
+    folderCache = {};
+    fileIdsCache = null;
+    async updateFileIdsJson(newFileId) {
+        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()}`;
+        };
+        try {
+            // ✅ Fetch `file_ids.json` ID once per session (cached)
+            if (!this.fileIdsCache) {
+                const existingFile = await this.fetcher({
+                    method: 'GET',
+                    headers: {},
+                    url: constructUrl(),
+                });
+                if (existingFile.files.length > 0) {
+                    this.fileIdsCache = existingFile.files[0].id;
+                }
+                else {
+                    console.log('No existing file_ids.json found, creating a new one.');
+                    this.fileIdsCache = null;
+                }
+            }
+            let existingFileIds = [];
+            // ✅ Fetch existing file IDs **only if `file_ids.json` exists**
+            if (this.fileIdsCache) {
+                try {
+                    const fileContent = await this.fetcher({
+                        method: 'GET',
+                        headers: {},
+                        url: `https://www.googleapis.com/drive/v3/files/${this.fileIdsCache}?alt=media`,
+                    });
+                    existingFileIds = fileContent;
+                }
+                catch (error) {
+                    console.log('Error fetching existing file_ids.json content, creating new list.');
+                }
+            }
+            // ✅ Append the new file ID to the list
+            existingFileIds.push(newFileId);
+            console.log('File ID saved to appDataFolder.', this.fileIdsCache);
+        }
+        catch (error) {
+            console.error('Error updating file_ids.json:', error.message);
+            throw error;
+        }
+    }
     constructor(accessToken) {
         this.accessToken = accessToken;
     }
@@ -28,7 +80,6 @@ export class GoogleDriveStorage {
                 },
                 body,
             });
-            // Check the Content-Type to ensure it's JSON before parsing
             const contentType = res.headers.get('Content-Type') || '';
             let data;
             if (contentType.includes('application/json')) {
@@ -39,7 +90,6 @@ export class GoogleDriveStorage {
                 console.error('Unexpected Response Type:', text);
                 throw new Error(`Expected JSON response but got: ${contentType}`);
             }
-            // Handle non-200 HTTP responses
             if (!res.ok) {
                 console.error('Error Response:', JSON.stringify(data));
                 throw new Error(data?.error?.message || 'Unknown error occurred');
@@ -54,11 +104,7 @@ export class GoogleDriveStorage {
     async getFileContent(fileId) {
         const url = `https://www.googleapis.com/drive/v3/files/${fileId}?alt=media`;
         try {
-            const response = await this.fetcher({
-                method: 'GET',
-                headers: {}, // Add additional headers if required
-                url,
-            });
+            const response = await this.fetcher({ method: 'GET', headers: {}, url });
             return response;
         }
         catch (error) {
@@ -72,11 +118,7 @@ export class GoogleDriveStorage {
             headers: {},
             url: `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&trashed=false&fields=files(id,name,mimeType,parents)`,
         });
-        if (!result.files) {
-            console.error('No files found:', result);
-            return [];
-        }
-        return result.files;
+        return result.files || [];
     }
     async createFolder({ folderName, parentFolderId }) {
         if (!parentFolderId) {
@@ -85,7 +127,7 @@ export class GoogleDriveStorage {
         const metadata = {
             name: folderName,
             mimeType: 'application/vnd.google-apps.folder',
-            parents: [parentFolderId], // Explicitly associate with the parent folder
+            parents: [parentFolderId],
         };
         const folder = await this.fetcher({
             method: 'POST',
@@ -94,110 +136,107 @@ export class GoogleDriveStorage {
             url: 'https://www.googleapis.com/drive/v3/files',
         });
         console.log(`Folder created: "${folderName}" with ID: ${folder.id}, Parent: ${parentFolderId}`);
+        await this.fetcher({
+            method: 'POST',
+            url: `https://www.googleapis.com/drive/v3/files/${folder.id}/permissions`,
+            headers: {},
+            body: JSON.stringify({ role: 'reader', type: 'anyone' }),
+        });
         return 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;
+    }
+    async uploadBinaryFile({ file }) {
+        try {
+            const accessToken = this.accessToken; // Ensure access token is available
+            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 metadata = {
+                name: file.name,
+                mimeType: file.type,
+                parents: [folderId], // Store in the correct folder
+            };
+            // ✅ Create FormData for multipart upload
+            const formData = new FormData();
+            formData.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }));
+            formData.append('file', file);
+            // ✅ Correct Google Drive Upload URL
+            const url = `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,parents`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${accessToken}`, // ✅ Include valid OAuth token
+                },
+                body: formData,
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new Error(`Google Drive Upload Error: ${data.error?.message || 'Unknown error'}`);
+            }
+            console.log('✅ File uploaded successfully:', data);
+            return data; // Returns the uploaded file ID and parents
+        }
+        catch (error) {
+            console.error('❌ Error uploading file to Google Drive:', error);
+            throw error;
+        }
+    }
     async saveFile({ data, folderId }) {
+        console.log('🚀 ~ GoogleDriveStorage ~ saveFile ~ data:', data);
         try {
             if (!folderId) {
                 throw new Error('Folder ID is required to save a file.');
             }
-            // Define file metadata, ensure correct folder is assigned
             const fileMetadata = {
-                name: data.fileName || 'resume.json', // Use the provided fileName or default to 'resume.json'
-                parents: [folderId], // Specify the folder ID
-                mimeType: 'application/json', // Ensure the MIME type is set to JSON
+                name: data.fileName || 'resume.json',
+                parents: [folderId],
+                mimeType: data.mimeType || 'application/json',
             };
-            // Check if the parent folder is in the trash
-            const folder = await this.fetcher({
-                method: 'GET',
-                headers: {},
-                url: `https://www.googleapis.com/drive/v3/files/${folderId}?fields=trashed`,
-            });
-            if (folder.trashed) {
-                throw new Error('Parent folder is in trash');
-            }
-            // Prepare the file content as a JSON string
-            const fileContent = JSON.stringify(data);
-            // Create a Blob from the JSON string
-            const fileBlob = new Blob([fileContent], { type: 'application/json' });
-            // Create FormData and append the metadata and file content
+            const fileBlob = new Blob([JSON.stringify(data)], { type: 'application/json' });
             const formData = new FormData();
             formData.append('metadata', new Blob([JSON.stringify(fileMetadata)], { type: 'application/json' }));
             formData.append('file', fileBlob);
-            // Upload file to Google Drive
-            console.log('Uploading file...');
             const file = await this.fetcher({
                 method: 'POST',
                 headers: {},
                 body: formData,
                 url: `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,parents`,
             });
-            // Set file permissions
+            // Set public read permissions
             await this.fetcher({
                 method: 'POST',
                 url: `https://www.googleapis.com/drive/v3/files/${file.id}/permissions`,
-                headers: {},
+                headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({
                     role: 'reader',
                     type: 'anyone',
                 }),
             });
-            // Check for existing file_ids.json in appDataFolder
-            let existingFileId = null;
-            let existingFileIds = [];
-            try {
-                const existingFileQuery = await this.fetcher({
-                    method: 'GET',
-                    headers: {},
-                    url: `https://www.googleapis.com/drive/v3/files?spaces=appDataFolder&q=name='file_ids.json'&fields=files(id)`,
-                });
-                if (existingFileQuery.files?.length > 0) {
-                    existingFileId = existingFileQuery.files[0].id;
-                    const fileContent = await this.fetcher({
-                        method: 'GET',
-                        headers: {},
-                        url: `https://www.googleapis.com/drive/v3/files/${existingFileId}?alt=media`,
-                    });
-                    existingFileIds = JSON.parse(fileContent);
-                }
-                console.log('existingFileId', existingFileId);
-            }
-            catch (error) {
-                console.log('Creating new file_ids.json');
-            }
-            // Add new file ID
-            existingFileIds.push(file.id);
-            // Metadata for app data file
-            const appDataFileMetadata = {
-                name: 'file_ids.json',
-                mimeType: 'application/json',
-                parents: ['appDataFolder'],
-            };
-            // Update or create file_ids.json
-            const formDataForAppData = new FormData();
-            formDataForAppData.append('metadata', new Blob([JSON.stringify(appDataFileMetadata)], { type: 'application/json' }));
-            formDataForAppData.append('file', new Blob([JSON.stringify(existingFileIds)], { type: 'application/json' }));
-            if (existingFileId) {
-                await this.fetcher({
-                    method: 'PATCH',
-                    headers: {},
-                    body: formDataForAppData,
-                    url: `https://www.googleapis.com/upload/drive/v3/files/${existingFileId}?uploadType=multipart&fields=id`,
-                });
-            }
-            else {
-                await this.fetcher({
-                    method: 'POST',
-                    headers: {},
-                    body: formDataForAppData,
-                    url: `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&spaces=appDataFolder`,
-                });
-            }
-            console.log(file);
+            console.log(`File uploaded successfully: ${file.id}`);
             return file;
         }
         catch (error) {
-            console.error('Error:', error.message);
+            console.error('Error in saveFile:', error);
             throw error;
         }
     }
@@ -207,10 +246,8 @@ export class GoogleDriveStorage {
      * @returns file content
      */
     async retrieve(id) {
-        const metadataUrl = `https://www.googleapis.com/drive/v3/files/${id}?fields=id,name`;
         const dataUrl = `https://www.googleapis.com/drive/v3/files/${id}?alt=media`;
         try {
-            // Fetch actual file data
             const dataResponse = await fetch(dataUrl, {
                 method: 'GET',
                 headers: {
@@ -223,7 +260,6 @@ export class GoogleDriveStorage {
                 return null;
             }
             const contentType = dataResponse.headers.get('Content-Type');
-            console.log(`File content type: ${contentType}`);
             let fileData;
             if (contentType?.includes('application/json')) {
                 fileData = await dataResponse.json();
@@ -242,7 +278,7 @@ export class GoogleDriveStorage {
             else {
                 fileData = await dataResponse.arrayBuffer();
             }
-            return { data: fileData };
+            return { data: fileData, id: id };
         }
         catch (error) {
             console.error(`Error retrieving file with ID ${id}:`, error.message);
@@ -254,13 +290,18 @@ export class GoogleDriveStorage {
      * @param folderId [Optional]
      * @returns
      */
-    findFolders = async (folderId) => {
+    async findFolders(folderId) {
+        const cacheKey = folderId || 'root';
+        if (this.folderCache[cacheKey]) {
+            return this.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);
-        return folders.filter((file) => file.mimeType === 'application/vnd.google-apps.folder');
-    };
+        this.folderCache[cacheKey] = folders;
+        return folders;
+    }
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type
@@ -268,58 +309,56 @@ export class GoogleDriveStorage {
      */
     async getAllFilesByType(type) {
         try {
-            // Step 1: Find the root 'Credentials' folder
-            const rootFolders = await this.findFolders();
-            const credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
+            if (!this.folderCache['Credentials']) {
+                const rootFolders = await this.findFolders();
+                this.folderCache['Credentials'] = rootFolders;
+            }
+            const credentialsFolder = this.folderCache['Credentials'].find((f) => f.name === 'Credentials');
             if (!credentialsFolder) {
                 console.error('Credentials folder not found.');
                 return [];
             }
-            const credentialsFolderId = credentialsFolder.id;
-            // Step 2: Handle special case for 'VCs'
             if (type === 'VCs') {
-                // Find the 'VCs' folder under 'Credentials'
-                const subfolders = await this.findFolders(credentialsFolderId);
-                const targetFolder = subfolders.find((f) => f.name === 'VCs');
-                if (!targetFolder) {
-                    console.error(`Folder for type ${type} not found.`);
+                if (!this.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-'));
+                }
+                const vcSubfolders = this.folderCache['VCs'];
+                if (!vcSubfolders.length) {
+                    console.error(`No subfolders found for type: ${type}`);
                     return [];
                 }
-                const targetFolderId = targetFolder.id;
-                // Fetch all 'VC-timestamp' subfolders under 'VCs'
-                const vcSubfolders = await this.findFolders(targetFolderId);
-                // Retrieve all 'VC.json' files from each 'VC-timestamp' subfolder
-                const fileContents = await Promise.all(vcSubfolders.map(async (folder) => {
-                    const files = await this.findFilesUnderFolder(folder.id);
-                    console.log('🚀 ~ GoogleDriveStorage ~ vcSubfolders.map ~ files:', files);
-                    return Promise.all(files.map(async (file) => {
-                        return await this.retrieve(file.id);
-                    }));
-                }));
-                console.log('🚀 ~ GoogleDriveStorage ~ getAllFilesByType ~ fileContents:', fileContents);
-                return fileContents;
+                const allFilesNested = await Promise.all(vcSubfolders.map(async (folder) => await this.findFilesUnderFolder(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');
             }
-            // Step 3: Generic handling for other types
-            const subfolders = await this.findFolders(credentialsFolderId);
-            const targetFolder = subfolders.find((f) => f.name === type);
-            if (!targetFolder) {
+            if (!this.folderCache[type]) {
+                const subfolders = await this.findFolders(credentialsFolder.id);
+                const targetFolder = subfolders.find((f) => f.name === type);
+                this.folderCache[type] = targetFolder ? targetFolder.id : null;
+            }
+            const targetFolderId = this.folderCache[type];
+            if (!targetFolderId) {
                 console.error(`Folder for type ${type} not found.`);
                 return [];
             }
             const filesResponse = await this.fetcher({
                 method: 'GET',
                 headers: {},
-                url: `https://www.googleapis.com/drive/v3/files?q='${targetFolder.id}' in parents and trashed=false&fields=files(id,name,mimeType,parents)`,
+                url: `https://www.googleapis.com/drive/v3/files?q='${targetFolderId}' in parents and trashed=false&fields=files(id,name,mimeType)`,
             });
-            const files = filesResponse.files;
-            const fileContents = await Promise.all(files.map(async (file) => {
-                return await this.retrieve(file.id);
-            }));
-            return fileContents;
+            const files = filesResponse.files || [];
+            const fileContents = await Promise.allSettled(files.map((file) => this.retrieve(file.id)));
+            console.log('🚀 ~ GoogleDriveStorage ~ getAllFilesByType ~ fileContents:', fileContents);
+            return fileContents.filter((res) => res.status === 'fulfilled').map((res) => res.value);
         }
         catch (error) {
             console.error(`Error getting files of type ${type}:`, error);
-            return []; // Return an empty array on error
+            return [];
         }
     }
     /**
@@ -330,9 +369,7 @@ export class GoogleDriveStorage {
      */
     async updateFileName(fileId, newFileName) {
         try {
-            const metadata = {
-                name: newFileName, // New name for the file
-            };
+            const metadata = { name: newFileName };
             const updatedFile = await this.fetcher({
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
@@ -348,7 +385,6 @@ export class GoogleDriveStorage {
         }
     }
     async findFileByName(name) {
-        // find the file named under Credentials folder
         const rootFolders = await this.findFolders();
         const credentialsFolderId = rootFolders.find((f) => f.name === 'Credentials')?.id;
         if (!credentialsFolderId)
@@ -364,7 +400,6 @@ export class GoogleDriveStorage {
             console.log('No files found in the folder.');
             return [];
         }
-        // Fetch content for each file
         const filesWithContent = await Promise.all(files.map(async (file) => {
             try {
                 const content = await this.getFileContent(file.id);
@@ -372,7 +407,7 @@ export class GoogleDriveStorage {
             }
             catch (error) {
                 console.error(`Error fetching content for file "${file.name}" (ID: ${file.id}):`, error);
-                return { ...file, content: null }; // Handle errors gracefully
+                return { ...file, content: null };
             }
         }));
         return filesWithContent;
@@ -382,12 +417,8 @@ export class GoogleDriveStorage {
             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({
-                    name: data.fileName,
-                }),
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name: data.fileName }),
                 url: updateUrl,
             });
             console.log('✅ File renamed successfully:', updatedFile);
@@ -398,44 +429,50 @@ export class GoogleDriveStorage {
         }
     }
     async getFileParents(fileId) {
-        console.log('🚀 ~ GoogleDriveStorage ~ getFileParents ~ fileId', fileId);
         const file = await this.fetcher({
             method: 'GET',
             headers: {},
             url: `https://www.googleapis.com/drive/v3/files/${fileId}?fields=parents`,
         });
+        console.log('FILE: ', file);
         return file.parents;
     }
     async updateRelationsFile({ relationsFileId, recommendationFileId }) {
         const relationsFileContent = await this.retrieve(relationsFileId);
-        const relationsData = relationsFileContent.data;
+        const relationsData = relationsFileContent.data.body ? JSON.parse(relationsFileContent.data.body) : relationsFileContent.data;
         relationsData.recommendations.push(recommendationFileId);
         const updatedContent = JSON.stringify(relationsData);
         const updateResponse = await this.fetcher({
             method: 'PATCH',
-            headers: {
-                'Content-Type': 'application/json',
-            },
+            headers: { 'Content-Type': 'application/json' },
             body: updatedContent,
             url: `https://www.googleapis.com/upload/drive/v3/files/${relationsFileId}?uploadType=media`,
         });
-        console.log('🚀 ~ GoogleDriveStorage ~ updateRelationsFile ~ updateResponse:', updateResponse);
+        this.updateFileIdsJson(relationsFileId);
         return updateResponse;
     }
     async createRelationsFile({ vcFolderId }) {
         const files = await this.findFilesUnderFolder(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',
                 mimeType: 'application/json',
                 body: JSON.stringify({
-                    vc_id: vcFile.id,
+                    vc: {
+                        fileId: vcContent.id,
+                        subject,
+                    },
                     recommendations: [],
                 }),
             },
             folderId: vcFolderId,
         });
+        await this.updateFileIdsJson(relationsFile.id);
         return relationsFile;
     }
     /**
@@ -459,25 +496,19 @@ export class GoogleDriveStorage {
         }
     }
     async update(fileId, data) {
-        console.log('🚀 ~ GoogleDriveStorage ~ update ~ data:', data);
-        console.log('🚀 ~ GoogleDriveStorage ~ update ~ fileId:', fileId);
-        // ✅ Ensure JSON file type
         const metadata = {
             name: data.fileName || 'resume.json',
             mimeType: 'application/json',
         };
         const uploadUrl = `https://www.googleapis.com/upload/drive/v3/files/${fileId}?uploadType=multipart`;
-        // ✅ Create multipart request to update Google Drive JSON file
         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' }) // ✅ Ensure JSON format
-        );
-        console.log('🚀 ~ GoogleDriveStorage ~ update ~ FormData:', formData);
+        formData.append('file', new Blob([JSON.stringify(data.body)], { type: 'application/json' }));
         try {
             const response = await this.fetcher({
                 method: 'PATCH',
-                headers: {}, // ✅ No Content-Type needed, let FormData set it
-                body: formData, // ✅ Sends JSON file properly
+                headers: {},
+                body: formData,
                 url: `${uploadUrl}&fields=id,name,mimeType`,
             });
             console.log('✅ File updated successfully:', response);
@@ -490,12 +521,22 @@ export class GoogleDriveStorage {
     }
     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: `https://www.googleapis.com/drive/v3/files?q=name='file_ids.json' and 'appDataFolder' in parents&fields=files(id)`,
+                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.');
@@ -503,14 +544,17 @@ export class GoogleDriveStorage {
             }
             // 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 = JSON.parse(fileContent);
+            const fileIds = fileContent;
+            console.log(':  GoogleDriveStorage  getFileIdsFromAppDataFolder  fileIds', fileIds);
             return fileIds;
         }
         catch (error) {