@cooperation/vc-storage 1.0.21 → 1.0.23

package/dist/models/CredentialEngine.js

@@ -5,11 +5,9 @@ import { v4 as uuidv4 } from 'uuid';
 import { extractKeyPairFromCredential, generateDIDSchema, generateUnsignedRecommendation, generateUnsignedVC, } from '../utils/credential.js';
 import { customDocumentLoader } from '../utils/digitalbazaar.js';
 import { saveToGoogleDrive } from '../utils/google.js';
-import { GoogleDriveStorage } from './GoogleDriveStorage.js';
 /**
  * Class representing the Credential Engine.
  * @class CredentialEngine
- * @param {string} accessToken - The access token for the user.
  * @classdesc Credential Engine class to create DIDs and VCs.
  * @method createDID - Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
  * @method createWalletDID - Create a new DID with user metamask address as controller.
@@ -21,8 +19,8 @@ import { GoogleDriveStorage } from './GoogleDriveStorage.js';
 export class CredentialEngine {
     storage;
     keyPair;
-    constructor(accessToken) {
-        this.storage = new GoogleDriveStorage(accessToken);
+    constructor(storage) {
+        this.storage = storage;
     }
     async getKeyPair(vc) {
         // Fetch all stored key pairs
@@ -73,11 +71,11 @@ export class CredentialEngine {
     async createDID() {
         try {
             const keyPair = await this.generateKeyPair();
-            const keyFile = await saveToGoogleDrive({
-                storage: this.storage,
-                data: keyPair,
-                type: 'KEYPAIR',
-            });
+            // const keyFile = await saveToGoogleDrive({
+            // 	storage: this.storage,
+            // 	data: keyPair,
+            // 	type: 'KEYPAIR',
+            // });
             const didDocument = await generateDIDSchema(keyPair);
             return { didDocument, keyPair };
         }
@@ -132,19 +130,14 @@ export class CredentialEngine {
      * @throws Will throw an error if VC signing fails.
      */
     async signVC({ data, type, keyPair, issuerId, vcFileId }) {
-        console.log('🚀 ~ CredentialEngine ~ signVC ~ { data, type, keyPair, issuerId, vcFileId }:', {
-            data,
-            type,
-            keyPair,
-            issuerId,
-            vcFileId,
-        });
-        let vc;
         let credential = generateUnsignedVC({ formData: data, issuerDid: issuerId });
         if (type == 'RECOMMENDATION' && vcFileId) {
             console.log('WOW');
-            vc = (await this.storage.retrieve(vcFileId));
-            credential = generateUnsignedRecommendation({ vc, recommendation: data, issuerDid: issuerId });
+            credential = generateUnsignedRecommendation({
+                vcId: vcFileId,
+                recommendation: data,
+                issuerDid: issuerId,
+            });
         }
         try {
             console.log('🚀 ~ CredentialEngine ~ signVC ~ credential:', credential);

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',
-                spaces: ['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`,
-                });
-            }
-            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) {

package/dist/models/ResumeVC.js

@@ -30,30 +30,33 @@ export class ResumeVC {
         return unsignedCredential;
     }
     generateUnsignedCredential({ formData, issuerDid }) {
-        const unsignedCredential = {
+        const unsignedResumeVC = {
             '@context': [
-                'https://www.w3.org/2018/credentials/v1', // Standard VC context
+                'https://www.w3.org/2018/credentials/v1',
+                'https://schema.hropenstandards.org/4.4/context.jsonld',
                 inlineResumeContext['@context'], // Inline context
             ],
-            id: `urn:uuid:${uuidv4()}`, // Generate a dynamic UUID
-            type: ['VerifiableCredential'],
+            id: `urn:uuid:${uuidv4()}`, // Generate a unique UUID
+            type: ['VerifiableCredential', 'LERRSCredential'], // LER-RS compliant credential type
             issuer: issuerDid,
-            issuanceDate: new Date().toISOString(),
+            issuanceDate: new Date().toISOString(), // Current date/time in ISO format
             credentialSubject: {
                 type: 'Resume',
                 person: {
                     name: {
-                        formattedName: formData.formattedName,
+                        formattedName: formData.formattedName || '',
                     },
-                    primaryLanguage: formData.primaryLanguage,
+                    primaryLanguage: formData.primaryLanguage || 'en',
                 },
-                narrative: formData.narrative,
-                employmentHistory: formData.employmentHistory,
-                skills: formData.skills,
-                educationAndLearning: formData.educationAndLearning,
+                narrative: {
+                    text: formData.narrative || 'Narrative text goes here',
+                },
+                employmentHistory: formData.employmentHistory || [],
+                skills: formData.skills || [],
+                educationAndLearning: formData.educationAndLearning || {},
             },
         };
-        return unsignedCredential;
+        return unsignedResumeVC;
     }
     generateKeyPair = async (address) => {
         // Generate the key pair using the library's method

package/dist/types/models/CredentialEngine.d.ts

@@ -1,4 +1,5 @@
 import { DidDocument, KeyPair, FormDataI, RecommendationFormDataI, VerifiableCredential } from '../../types/credential.js';
+import { GoogleDriveStorage } from './GoogleDriveStorage.js';
 interface SignPropsI {
     data: FormDataI | RecommendationFormDataI;
     type: 'VC' | 'RECOMMENDATION';
@@ -9,7 +10,6 @@ interface SignPropsI {
 /**
  * Class representing the Credential Engine.
  * @class CredentialEngine
- * @param {string} accessToken - The access token for the user.
  * @classdesc Credential Engine class to create DIDs and VCs.
  * @method createDID - Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
  * @method createWalletDID - Create a new DID with user metamask address as controller.
@@ -21,7 +21,7 @@ interface SignPropsI {
 export declare class CredentialEngine {
     private storage;
     private keyPair;
-    constructor(accessToken: string);
+    constructor(storage: GoogleDriveStorage);
     private getKeyPair;
     private generateKeyPair;
     private verifyCreds;

package/dist/types/models/GoogleDriveStorage.d.ts

@@ -1,8 +1,4 @@
-interface FileContent {
-    name: string;
-    content: any;
-    comments: string[];
-}
+type FileType = 'KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs' | 'MEDIAs';
 /**
  * @class GoogleDriveStorage
  * @description Class to interact with Google Drive API
@@ -20,6 +16,9 @@ interface FileContent {
  */
 export declare class GoogleDriveStorage {
     private accessToken;
+    folderCache: any;
+    private fileIdsCache;
+    private updateFileIdsJson;
     constructor(accessToken: string);
     private fetcher;
     private getFileContent;
@@ -27,12 +26,11 @@ export declare class GoogleDriveStorage {
     createFolder({ folderName, parentFolderId }: {
         folderName: string;
         parentFolderId: string;
-    }): Promise<{
-        id: string;
-        name: string;
-        mimeType: string;
-        parents: string[];
-    }>;
+    }): Promise<any>;
+    getMediaFolderId(): Promise<any>;
+    uploadBinaryFile({ file }: {
+        file: File;
+    }): Promise<any>;
     saveFile({ data, folderId }: {
         data: any;
         folderId: string;
@@ -44,19 +42,20 @@ export declare class GoogleDriveStorage {
      */
     retrieve(id: string): Promise<{
         data: any;
+        id: string;
     } | null>;
     /**
      * Get folder by folderId, if folderId == null you will have them all
      * @param folderId [Optional]
      * @returns
      */
-    findFolders: (folderId?: string) => Promise<any[]>;
+    findFolders(folderId?: string): Promise<any[]>;
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type
      * @returns
      */
-    getAllFilesByType(type: 'KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs' | 'MEDIAs'): Promise<FileContent[]>;
+    getAllFilesByType(type: FileType): Promise<any[]>;
     /**
      * Update the name of a file in Google Drive
      * @param fileId - The ID of the file to update

package/dist/types/models/ResumeVC.d.ts

@@ -4,7 +4,10 @@ export declare class ResumeVC {
         issuerDid: string;
         keyPair: any;
     }): Promise<any>;
-    private generateUnsignedCredential;
+    generateUnsignedCredential({ formData, issuerDid }: {
+        formData: any;
+        issuerDid: string;
+    }): any;
     generateKeyPair: (address?: string) => Promise<any>;
     /**
      * Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.

package/dist/types/utils/credential.d.ts

@@ -29,8 +29,8 @@ export declare function generateUnsignedVC({ formData, issuerDid }: {
  * @returns {RecommendationCredential} The created unsigned Recommendation Credential.
  * @throws Will throw an error if the recommendation creation fails or if issuance date exceeds expiration date.
  */
-export declare function generateUnsignedRecommendation({ vc, recommendation, issuerDid, }: {
-    vc: any;
+export declare function generateUnsignedRecommendation({ vcId, recommendation, issuerDid, }: {
+    vcId: string;
     recommendation: RecommendationFormDataI;
     issuerDid: string;
 }): RecommendationCredential;

package/dist/types/utils/google.d.ts

@@ -12,8 +12,9 @@ export declare const getVCWithRecommendations: ({ vcId, storage }: {
 }) => Promise<{
     vc: {
         data: any;
+        id: string;
     };
-    recommendations: any[];
+    recommendationIds: any;
     relationsFileId: any;
 }>;
 /**
@@ -26,13 +27,14 @@ export declare const getVCWithRecommendations: ({ vcId, storage }: {
  */
 export declare function saveToGoogleDrive({ storage, data, type }: SaveToGooglePropsI): Promise<any>;
 /**
- * Upload an image to Google Drive in the Credentials/MEDIAs folder.
+ * Upload any type of file to Google Drive in the Credentials/MEDIAs folder.
  * @param {GoogleDriveStorage} storage - The GoogleDriveStorage instance.
- * @param {File} imageFile - The image file to upload.
- * @returns {Promise<>} - The uploaded image file object.
+ * @param {File} file - The file to upload.
+ * @param {string} folderName - The name of the folder where the file will be saved (default is 'MEDIAs').
+ * @returns {Promise<{ id: string }>} - The uploaded file object.
  * @throws Will throw an error if the upload operation fails.
  */
-export declare function uploadImageToGoogleDrive(storage: GoogleDriveStorage, imageFile: File): Promise<{
+export declare function uploadToGoogleDrive(storage: GoogleDriveStorage, file: File, folderName?: string): Promise<{
     id: string;
 }>;
 export declare function generateViewLink(fileId: string): string;

package/dist/utils/credential.js

@@ -131,10 +131,7 @@ export function generateUnsignedVC({ formData, issuerDid }) {
  * @returns {RecommendationCredential} The created unsigned Recommendation Credential.
  * @throws Will throw an error if the recommendation creation fails or if issuance date exceeds expiration date.
  */
-export function generateUnsignedRecommendation({ vc, recommendation, issuerDid, }) {
-    console.log('🚀 ~ vc.id:', vc.id);
-    console.log('🚀 ~ vc:', vc);
-    console.log('🚀 ~ recommendation:', recommendation);
+export function generateUnsignedRecommendation({ vcId, recommendation, issuerDid, }) {
     const issuanceDate = new Date().toISOString();
     if (issuanceDate > recommendation.expirationDate)
         throw new Error('issuanceDate cannot be after expirationDate');
@@ -150,7 +147,7 @@ export function generateUnsignedRecommendation({ vc, recommendation, issuerDid,
                 portfolio: 'https://schema.org/portfolio',
             },
         ],
-        id: '', // Will be set after hashing VC
+        id: `urn:${generateHashedId({ id: vcId })}`,
         type: ['VerifiableCredential', 'https://schema.org/RecommendationCredential'],
         issuer: {
             id: issuerDid,
@@ -170,8 +167,6 @@ export function generateUnsignedRecommendation({ vc, recommendation, issuerDid,
             })),
         },
     };
-    // Use the VC's hashed ID for the Recommendation's ID
-    unsignedRecommendation.id = vc.data.id;
     return unsignedRecommendation;
 }
 /**

package/dist/utils/google.js

@@ -1,16 +1,18 @@
 export const getVCWithRecommendations = async ({ vcId, storage }) => {
-    const vcFolderId = await storage.getFileParents(vcId);
-    const files = await storage.findFilesUnderFolder(vcFolderId);
-    const relationsFile = files.find((f) => f.name === 'RELATIONS');
-    const relationsContent = await storage.retrieve(relationsFile.id);
-    const relationsData = relationsContent.data;
-    const [vcFileId, recommendationIds] = [relationsData.vc_id, relationsData.recommendations];
-    const vc = await storage.retrieve(vcFileId);
-    const recommendations = await Promise.all(recommendationIds.map(async (rec) => {
-        const recFile = await storage.retrieve(rec);
-        return recFile;
-    }));
-    return { vc: vc, recommendations, relationsFileId: relationsFile.id };
+    try {
+        const vcFolderId = await storage.getFileParents(vcId);
+        const files = await storage.findFilesUnderFolder(vcFolderId);
+        const relationsFile = files.find((f) => f.name === 'RELATIONS');
+        const relationsContent = await storage.retrieve(relationsFile.id);
+        const relationsData = relationsContent.data.body ? JSON.parse(relationsContent.data.body) : relationsContent.data;
+        const recommendationIds = relationsData.recommendations || [];
+        const vc = await storage.retrieve(vcId);
+        return { vc: vc, recommendationIds, relationsFileId: relationsFile.id };
+    }
+    catch (error) {
+        console.error('Error getting VC with recommendations:', error);
+        throw error;
+    }
 };
 /**
  * Save data to Google Drive in the specified folder type.
@@ -53,7 +55,6 @@ export async function saveToGoogleDrive({ storage, data, type }) {
         }
         // Save the file in the specific subfolder
         const file = await storage.saveFile({ data: fileData, folderId: typeFolderId });
-        console.log('🚀 ~ file:', file);
         return file;
     }
     catch (error) {
@@ -62,17 +63,19 @@ export async function saveToGoogleDrive({ storage, data, type }) {
     }
 }
 /**
- * Upload an image to Google Drive in the Credentials/MEDIAs folder.
+ * Upload any type of file to Google Drive in the Credentials/MEDIAs folder.
  * @param {GoogleDriveStorage} storage - The GoogleDriveStorage instance.
- * @param {File} imageFile - The image file to upload.
- * @returns {Promise<>} - The uploaded image file object.
+ * @param {File} file - The file to upload.
+ * @param {string} folderName - The name of the folder where the file will be saved (default is 'MEDIAs').
+ * @returns {Promise<{ id: string }>} - The uploaded file object.
  * @throws Will throw an error if the upload operation fails.
  */
-export async function uploadImageToGoogleDrive(storage, imageFile) {
+export async function uploadToGoogleDrive(storage, file, folderName = 'MEDIAs') {
     try {
         const rootFolders = await storage.findFolders();
         let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
         if (!credentialsFolder) {
+            console.log('Creating Credentials folder...');
             credentialsFolder = await storage.createFolder({ folderName: 'Credentials', parentFolderId: 'root' });
         }
         const credentialsFolderId = credentialsFolder.id;
@@ -83,17 +86,16 @@ export async function uploadImageToGoogleDrive(storage, imageFile) {
         }
         const mediasFolderId = mediasFolder.id;
         // Prepare the image file data
-        const imageData = {
-            fileName: imageFile.name,
-            mimeType: imageFile.type,
-            body: imageFile,
+        const fileMetaData = {
+            fileName: file.name,
+            mimeType: file.type,
+            body: file,
         };
         // SaveFile the image in the "MEDIAs" folder
         const uploadedImage = await storage.saveFile({
-            data: imageData,
+            data: fileMetaData,
             folderId: mediasFolderId,
         });
-        console.log('🚀 ~ uploadedImage:', uploadedImage);
         return uploadedImage;
     }
     catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.21",
+	"version": "1.0.23",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -10,7 +10,7 @@
 	],
 	"scripts": {
 		"build": "tsc",
-		"test": "jest",
+		"test": "vitest",
 		"version": "npm version patch"
 	},
 	"author": "cooperation",
@@ -22,26 +22,18 @@
 		"@digitalbazaar/vc": "^6.3.0",
 		"crypto-js": "^4.2.0",
 		"ethers": "^6.13.2",
+		"jest": "^29.7.0",
+		"ts-jest": "^29.2.5",
 		"ts-node": "^10.9.2",
 		"tsc": "^2.0.4",
 		"uuid": "^10.0.0"
 	},
 	"devDependencies": {
 		"@types/fs-extra": "^11.0.4",
-		"@types/jest": "^29.5.12",
+		"@types/jest": "^29.5.14",
 		"@types/uuid": "^10.0.0",
-		"typescript": "^5.6.2"
-	},
-	"jest": {
-		"preset": "ts-jest",
-		"testEnvironment": "node",
-		"moduleFileExtensions": [
-			"ts",
-			"tsx",
-			"js"
-		],
-		"roots": [
-			"<rootDir>/tests"
-		]
+		"babel-jest": "^29.7.0",
+		"typescript": "^5.6.2",
+		"vitest": "^3.0.5"
 	}
 }