@cooperation/vc-storage 1.0.10 → 1.0.12

package/dist/models/CredentialEngine.js

@@ -1,6 +1,6 @@
 import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
 import { Ed25519Signature2020 } from '@digitalbazaar/ed25519-signature-2020';
-import * as vc from '@digitalbazaar/vc';
+import * as dbVc from '@digitalbazaar/vc';
 import { v4 as uuidv4 } from 'uuid';
 import { extractKeyPairFromCredential, generateDIDSchema, generateUnsignedRecommendation, generateUnsignedVC, } from '../utils/credential.js';
 import { customDocumentLoader } from '../utils/digitalbazaar.js';
@@ -19,11 +19,9 @@ import { GoogleDriveStorage } from './GoogleDriveStorage.js';
  * @method signPresentation - Sign a Verifiable Presentation (VP).
  */
 export class CredentialEngine {
-    uuid;
     storage;
     keyPair;
     constructor(accessToken) {
-        this.uuid = uuidv4();
         this.storage = new GoogleDriveStorage(accessToken);
     }
     async getKeyPair(vc) {
@@ -75,8 +73,11 @@ export class CredentialEngine {
     async createDID() {
         try {
             const keyPair = await this.generateKeyPair();
-            const keyFile = await saveToGoogleDrive(this.storage, keyPair, 'KEYPAIR', this.uuid);
-            console.log('🚀 ~ CredentialEngine ~ createDID ~ keyFile:', keyFile);
+            const keyFile = await saveToGoogleDrive({
+                storage: this.storage,
+                data: keyPair,
+                type: 'KEYPAIR',
+            });
             const didDocument = await generateDIDSchema(keyPair);
             return { didDocument, keyPair };
         }
@@ -85,6 +86,23 @@ export class CredentialEngine {
             throw error;
         }
     }
+    async findKeysAndDIDs() {
+        // find the DID document for the current user
+        const keyPairs = (await this.storage.getAllFilesByType('KEYPAIRs'));
+        console.log('🚀 ~ CredentialEngine ~ findDid ~ keyPairs:', keyPairs[0].data);
+        const DIDs = (await this.storage.getAllFilesByType('DIDs'));
+        console.log('🚀 ~ CredentialEngine ~ findKeysAndDIDs ~ DIDs:', DIDs);
+        console.log('🚀 ~ CredentialEngine ~ findKeysAndDIDs ~ DIDs:', DIDs[0]);
+        if (DIDs.length === 0 || keyPairs.length === 0)
+            return null;
+        const keyPair = keyPairs[0].data;
+        const didDocument = DIDs[0].data.didDocument;
+        console.log('🚀 ~ CredentialEngine ~ findKeysAndDIDs ~ didDocument:', didDocument);
+        return {
+            didDocument,
+            keyPair,
+        };
+    }
     /**
      * Create a new DID with user metamask address as controller
      * @param walletrAddress
@@ -94,7 +112,11 @@ export class CredentialEngine {
     async createWalletDID(walletrAddress) {
         try {
             const keyPair = await this.generateKeyPair(walletrAddress);
-            const keyFile = await saveToGoogleDrive(this.storage, keyPair, 'KEYPAIR', this.uuid);
+            const keyFile = await saveToGoogleDrive({
+                storage: this.storage,
+                data: keyPair,
+                type: 'KEYPAIR',
+            });
             console.log('🚀 ~ CredentialEngine ~ createWalletDID ~ keyFile:', keyFile);
             const didDocument = await generateDIDSchema(keyPair);
             return { didDocument, keyPair };
@@ -109,20 +131,33 @@ export class CredentialEngine {
      * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
      * @param {string} issuerId - The ID of the issuer [currently we put it as the did id]
      * @param {KeyPair} keyPair - The key pair to use for signing.
+     * @param {FormDataI | RecommendationFormDataI} formData - The form data to include in the VC.
+     * @param {string} VCId - The ID of the credential when the type is RECOMMENDATION
      * @returns {Promise<Credential>} The signed VC.
      * @throws Will throw an error if VC signing fails.
      */
-    async signVC(formData, type, keyPair, issuerId) {
-        let credential;
-        if (type == 'VC') {
-            credential = generateUnsignedVC(formData, issuerId, this.uuid);
-        }
-        else if (type == 'RECOMMENDATION') {
-            credential = generateUnsignedRecommendation(formData, issuerId);
+    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 });
         }
-        const suite = new Ed25519Signature2020({ key: keyPair, verificationMethod: keyPair.id });
         try {
-            const signedVC = await vc.issue({ credential, suite, documentLoader: customDocumentLoader });
+            console.log('🚀 ~ CredentialEngine ~ signVC ~ credential:', credential);
+            if (!credential)
+                throw new Error('Invalid credential type');
+            const suite = new Ed25519Signature2020({ key: keyPair, verificationMethod: keyPair.id });
+            console.log('before');
+            const signedVC = await dbVc.issue({ credential, suite, documentLoader: customDocumentLoader });
             return signedVC;
         }
         catch (error) {
@@ -143,7 +178,7 @@ export class CredentialEngine {
                 key: keyPair,
                 verificationMethod: keyPair.id,
             });
-            const result = await vc.verifyCredential({
+            const result = await dbVc.verifyCredential({
                 credential,
                 suite,
                 documentLoader: customDocumentLoader,
@@ -169,7 +204,7 @@ export class CredentialEngine {
             const id = `urn:uuid:${uuidv4()}`;
             const keyPair = await this.getKeyPair(verifiableCredential[0]);
             console.log('🚀 ~ CredentialEngine ~ createPresentation ~ keyPair:', keyPair);
-            const VP = await vc.createPresentation({ verifiableCredential, id, holder: keyPair.controller });
+            const VP = await dbVc.createPresentation({ verifiableCredential, id, holder: keyPair.controller });
             return VP;
         }
         catch (error) {
@@ -198,7 +233,7 @@ export class CredentialEngine {
                 verificationMethod: this.keyPair.id,
             });
             // Sign the presentation
-            const signedVP = await vc.signPresentation({
+            const signedVP = await dbVc.signPresentation({
                 presentation,
                 suite,
                 documentLoader: customDocumentLoader,

package/dist/models/GoogleDriveStorage.js

@@ -1,4 +1,3 @@
-import { generateViewLink } from '../utils/google.js';
 /**
  * @class GoogleDriveStorage
  * @description Class to interact with Google Drive API
@@ -19,7 +18,6 @@ export class GoogleDriveStorage {
     constructor(accessToken) {
         this.accessToken = accessToken;
     }
-    // Method to fetch data from Google Drive API
     async fetcher({ method, headers, body, url }) {
         try {
             const res = await fetch(url, {
@@ -30,26 +28,39 @@ export class GoogleDriveStorage {
                 }),
                 body,
             });
-            // Check for errors in the response
-            const data = await res.json();
+            // 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')) {
+                data = await res.json();
+            }
+            else {
+                const text = await res.text();
+                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');
+                throw new Error(data?.error?.message || 'Unknown error occurred');
             }
             return data;
         }
         catch (error) {
-            console.error('Error fetching data:', error.message);
+            console.error('Error fetching data:', error.message || error);
             throw error;
         }
     }
-    // Method to search for files in Google Drive by query
     async searchFiles(query) {
         const result = await this.fetcher({
             method: 'GET',
             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;
     }
     async createFolder(folderName, parentFolderId) {
@@ -67,7 +78,7 @@ export class GoogleDriveStorage {
         console.log('Folder ID:', folder.id);
         return folder.id;
     }
-    async save(data, folderId) {
+    async saveFile({ data, folderId }) {
         try {
             // Define file metadata, ensure correct folder is assigned
             const fileMetadata = {
@@ -79,86 +90,32 @@ export class GoogleDriveStorage {
             const formData = new FormData();
             formData.append('metadata', new Blob([JSON.stringify(fileMetadata)], { type: 'application/json' }));
             formData.append('file', new Blob([data.body], { type: fileMetadata.mimeType })); // Set file data and MIME type
+            // Upload file to Google Drive
             const file = await this.fetcher({
                 method: 'POST',
                 headers: {},
                 body: formData,
-                url: uploadUrl,
-            });
-            console.log('File uploaded successfully:', file.id);
-            return file;
-        }
-        catch (error) {
-            console.error('Error uploading file:', error.message);
-            return null;
-        }
-    }
-    /**
-     * Add comment to VC
-     * @param fileId - th id of VC file
-     * @returns
-     */
-    async addCommentToFile(vcFileId, recommendationFileId) {
-        if (!recommendationFileId || !vcFileId || !this.accessToken) {
-            throw new Error('Missing required parameters: fileId, commentText, or accessToken');
-        }
-        const url = `https://www.googleapis.com/drive/v3/files/${vcFileId}/comments?fields=id,content,createdTime`;
-        const body = {
-            content: generateViewLink(recommendationFileId),
-        };
-        try {
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${this.accessToken}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(body),
+                url: `${uploadUrl}&fields=id,parents`, // Request the file ID and parent folder IDs
             });
-            if (!response.ok) {
-                const errorDetails = await response.json();
-                throw new Error(`Failed to add comment: ${JSON.stringify(errorDetails)}`);
-            }
-            const result = await response.json();
-            console.log('Comment added successfully:', result);
-            return result;
-        }
-        catch (error) {
-            console.error('Error adding comment to file:', error);
-            throw error;
-        }
-    }
-    /**
-     * Add commenter role to a file
-     * @param fileId
-     * @returns
-     */
-    async addCommenterRoleToFile(fileId) {
-        const url = `https://www.googleapis.com/drive/v3/files/${fileId}/permissions`;
-        const body = {
-            role: 'commenter',
-            type: 'anyone',
-        };
-        try {
-            const response = await fetch(url, {
+            // Set the file permission to "Anyone with the link" can view
+            const permissionUrl = `https://www.googleapis.com/drive/v3/files/${file.id}/permissions`;
+            const permissionData = {
+                role: 'reader',
+                type: 'anyone', // Public access
+            };
+            await this.fetcher({
                 method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${this.accessToken}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(body),
+                url: permissionUrl,
+                headers: {},
+                body: JSON.stringify(permissionData),
             });
-            if (!response.ok) {
-                const errorDetails = await response.json();
-                throw new Error(`Failed to add permission: ${JSON.stringify(errorDetails)}`);
-            }
-            const result = await response.json();
-            console.log('Permission added successfully:', result);
-            return result;
+            console.log('Permission set to public for file:', file.id);
+            console.log('Parent folder IDs:', file.parents);
+            return file;
         }
         catch (error) {
-            console.error('Error adding permission:', error.message);
-            throw error;
+            console.error('Error uploading file or setting permission:', error.message);
+            return null;
         }
     }
     /**
@@ -167,25 +124,24 @@ export class GoogleDriveStorage {
      * @returns file content
      */
     async retrieve(id) {
-        const metadataUrl = `https://www.googleapis.com/drive/v3/files/${id}?fields=name`;
+        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 {
-            console.log(`Starting retrieval for file ID: ${id}`);
-            // Fetch file metadata to get the name
-            const metadataResponse = await fetch(metadataUrl, {
+            // Initial "touch" request to ensure file accessibility for the current user
+            const touchResponse = await fetch(metadataUrl, {
                 method: 'GET',
                 headers: {
                     Authorization: `Bearer ${this.accessToken}`,
                 },
             });
-            if (!metadataResponse.ok) {
-                const errorData = await metadataResponse.json();
-                console.error(`Failed to retrieve metadata for file ID ${id}:`, errorData);
+            if (!touchResponse.ok) {
+                const errorData = await touchResponse.json();
+                console.error(`Failed to "touch" file for accessibility with ID ${id}:`, errorData);
                 return null;
             }
-            const metadata = await metadataResponse.json();
+            // Fetch file metadata to get the name
+            const metadata = await touchResponse.json();
             const fileName = metadata.name;
-            console.log(`File name retrieved: ${fileName}`);
             // Fetch actual file data
             const dataResponse = await fetch(dataUrl, {
                 method: 'GET',
@@ -221,9 +177,8 @@ export class GoogleDriveStorage {
             else {
                 fileData = await dataResponse.arrayBuffer(); // Fallback for other binary types
             }
-            console.log('🚀 ~ GoogleDriveStorage ~ retrieve ~ fileData:', fileData);
             // Return file ID, name, and data
-            return { id, name: fileName, data: fileData };
+            return { id: metadata.id, name: fileName, data: fileData };
         }
         catch (error) {
             console.error(`Error retrieving file with ID ${id}:`, error.message);
@@ -232,7 +187,7 @@ export class GoogleDriveStorage {
     }
     /**
      * Get folder by folderId, if folderId == null you will have them all
-     * @param id [Optional]
+     * @param folderId [Optional]
      * @returns
      */
     findFolders = async (folderId) => {
@@ -294,22 +249,6 @@ export class GoogleDriveStorage {
             return null;
         }
     };
-    async getFileComments(fileId) {
-        try {
-            // Fetch comments on the file using Google Drive API
-            const commentsResponse = await this.fetcher({
-                method: 'GET',
-                headers: {},
-                url: `https://www.googleapis.com/drive/v3/files/${fileId}/comments?fields=comments(content,author/displayName,createdTime)`,
-            });
-            // Return the comments data if available
-            return commentsResponse.comments || []; // Return an empty array if no comments
-        }
-        catch (error) {
-            console.error(`Failed to fetch comments for file ID: ${fileId}`, error);
-            return []; // Handle errors by returning an empty array or some error indication
-        }
-    }
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type
@@ -317,42 +256,60 @@ export class GoogleDriveStorage {
      */
     async getAllFilesByType(type) {
         try {
-            // Step 1: Find all root folders
+            // Step 1: Find the root 'Credentials' folder
             const rootFolders = await this.findFolders();
             const credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
-            if (!credentialsFolder)
+            if (!credentialsFolder) {
+                console.error('Credentials folder not found.');
                 return [];
+            }
             const credentialsFolderId = credentialsFolder.id;
-            // Step 2: Find the subfolder corresponding to the specified type
+            // 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.`);
+                    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 = [];
+                for (const folder of vcSubfolders) {
+                    const files = await this.findFilesUnderFolder(folder.id);
+                    // Fetch the content of each file
+                    for (const file of files) {
+                        try {
+                            const content = await this.retrieve(file.id);
+                            fileContents.push(content);
+                        }
+                        catch (error) {
+                            console.error(`Error retrieving content for file ${file.id}:`, error);
+                        }
+                    }
+                }
+                return fileContents;
+            }
+            // Step 3: Generic handling for other types
             const subfolders = await this.findFolders(credentialsFolderId);
             const targetFolder = subfolders.find((f) => f.name === type);
-            if (!targetFolder)
+            if (!targetFolder) {
+                console.error(`Folder for type ${type} not found.`);
                 return [];
-            // Step 3: Fetch all files in the specified folder
+            }
             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)`,
             });
             const files = filesResponse.files;
-            // Step 4: Fetch the content and comments of each file
             const fileContents = await Promise.all(files.map(async (file) => {
-                // Fetch file content
-                const content = await this.fetcher({
-                    method: 'GET',
-                    headers: {},
-                    url: `https://www.googleapis.com/drive/v3/files/${file.id}?alt=media`,
-                });
-                // Fetch file comments (if applicable)
-                const comments = await this.getFileComments(file.id);
-                return {
-                    id: file.id,
-                    name: file.name,
-                    content,
-                    comments: comments.map((comment) => comment.content),
-                };
+                return await this.retrieve(file.id);
             }));
-            return fileContents; // Return the list of files with their content and comments
+            return fileContents;
         }
         catch (error) {
             console.error(`Error getting files of type ${type}:`, error);
@@ -384,6 +341,81 @@ export class GoogleDriveStorage {
             throw error;
         }
     }
+    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)
+            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');
+        console.log('🚀 ~ GoogleDriveStorage ~ findFilesUnderFolder ~ folderId', folderId);
+        const files = await this.searchFiles(`'${folderId}' in parents`);
+        return files;
+    }
+    async updateFileData(fileId, data) {
+        const fileMetadata = {
+            name: data.fileName,
+            mimeType: data.mimeType,
+        };
+        let uploadUrl = `https://www.googleapis.com/upload/drive/v3/files/${fileId}?uploadType=multipart`;
+        const formData = new FormData();
+        formData.append('metadata', new Blob([JSON.stringify(fileMetadata)], { type: 'application/json' }));
+        formData.append('file', new Blob([data.body], { type: fileMetadata.mimeType }));
+        const updatedFile = await this.fetcher({
+            method: 'PATCH',
+            headers: {},
+            body: JSON.stringify(formData),
+            url: `${uploadUrl}&fields=id,parents`,
+        });
+        console.log('File updated:', updatedFile);
+        return updatedFile;
+    }
+    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`,
+        });
+        return file.parents;
+    }
+    async updateRelationsFile({ relationsFileId, recommendationFileId }) {
+        const relationsFileContent = await this.retrieve(relationsFileId);
+        const relationsData = relationsFileContent.data;
+        relationsData.recommendations.push(recommendationFileId);
+        const updatedContent = JSON.stringify(relationsData);
+        const updateResponse = await this.fetcher({
+            method: 'PATCH',
+            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);
+        return updateResponse;
+    }
+    async createRelationsFile({ vcFolderId }) {
+        const files = await this.findFilesUnderFolder(vcFolderId);
+        const vcFile = files.find((file) => file.name === 'VC');
+        const relationsFile = await this.saveFile({
+            data: {
+                fileName: 'RELATIONS',
+                mimeType: 'application/json',
+                body: JSON.stringify({
+                    vc_id: vcFile.id,
+                    recommendations: [],
+                }),
+            },
+            folderId: vcFolderId,
+        });
+        return relationsFile;
+    }
     /**
      * Delete file by id
      * @param id

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

@@ -1,4 +1,11 @@
-import { DidDocument, KeyPair, VerifiableCredential } from '../../types/credential.js';
+import { DidDocument, KeyPair, FormDataI, RecommendationFormDataI, VerifiableCredential } from '../../types/credential.js';
+interface SignPropsI {
+    data: FormDataI | RecommendationFormDataI;
+    type: 'VC' | 'RECOMMENDATION';
+    keyPair: KeyPair;
+    issuerId: string;
+    vcFileId?: string;
+}
 /**
  * Class representing the Credential Engine.
  * @class CredentialEngine
@@ -12,7 +19,6 @@ import { DidDocument, KeyPair, VerifiableCredential } from '../../types/credenti
  * @method signPresentation - Sign a Verifiable Presentation (VP).
  */
 export declare class CredentialEngine {
-    private uuid;
     private storage;
     private keyPair;
     constructor(accessToken: string);
@@ -28,6 +34,10 @@ export declare class CredentialEngine {
         didDocument: DidDocument;
         keyPair: KeyPair;
     }>;
+    findKeysAndDIDs(): Promise<{
+        didDocument: any;
+        keyPair: any;
+    }>;
     /**
      * Create a new DID with user metamask address as controller
      * @param walletrAddress
@@ -43,10 +53,12 @@ export declare class CredentialEngine {
      * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
      * @param {string} issuerId - The ID of the issuer [currently we put it as the did id]
      * @param {KeyPair} keyPair - The key pair to use for signing.
+     * @param {FormDataI | RecommendationFormDataI} formData - The form data to include in the VC.
+     * @param {string} VCId - The ID of the credential when the type is RECOMMENDATION
      * @returns {Promise<Credential>} The signed VC.
      * @throws Will throw an error if VC signing fails.
      */
-    signVC(formData: any, type: 'VC' | 'RECOMMENDATION', keyPair: KeyPair, issuerId: string): Promise<any>;
+    signVC({ data, type, keyPair, issuerId, vcFileId }: SignPropsI): Promise<any>;
     /**
      * Verify a Verifiable Credential (VC)
      * @param {object} credential - The Verifiable Credential to verify.
@@ -67,3 +79,4 @@ export declare class CredentialEngine {
      */
     signPresentation(presentation: any): Promise<any>;
 }
+export {};

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

@@ -1,4 +1,4 @@
-import { DataToSaveI } from '../../types';
+import { DataToSaveI, FilesType } from '../../types';
 interface FileContent {
     name: string;
     content: any;
@@ -25,34 +25,23 @@ export declare class GoogleDriveStorage {
     private fetcher;
     private searchFiles;
     createFolder(folderName: string, parentFolderId?: string): Promise<string>;
-    save(data: DataToSaveI, folderId: string): Promise<{
-        id: string;
-    } | null>;
-    /**
-     * Add comment to VC
-     * @param fileId - th id of VC file
-     * @returns
-     */
-    addCommentToFile(vcFileId: string, recommendationFileId: string): Promise<any>;
-    /**
-     * Add commenter role to a file
-     * @param fileId
-     * @returns
-     */
-    addCommenterRoleToFile(fileId: string): Promise<any>;
+    saveFile({ data, folderId }: {
+        data: DataToSaveI;
+        folderId: string;
+    }): Promise<any>;
     /**
      * Get file from google drive by id
      * @param id
      * @returns file content
      */
     retrieve(id: string): Promise<{
-        id: string;
         name: string;
         data: any;
+        id: string;
     } | null>;
     /**
      * Get folder by folderId, if folderId == null you will have them all
-     * @param id [Optional]
+     * @param folderId [Optional]
      * @returns
      */
     findFolders: (folderId?: string) => Promise<any[]>;
@@ -62,7 +51,6 @@ export declare class GoogleDriveStorage {
      * @returns last file content from folder by folderId
      */
     findLastFile: (folderId: string) => Promise<any>;
-    getFileComments(fileId: string): Promise<any>;
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type
@@ -76,6 +64,17 @@ export declare class GoogleDriveStorage {
      * @returns The updated file metadata, including the new name
      */
     updateFileName(fileId: string, newFileName: string): Promise<any>;
+    findFileByName(name: FilesType): Promise<any>;
+    findFilesUnderFolder(folderId: string): Promise<any[]>;
+    updateFileData(fileId: string, data: DataToSaveI): Promise<any>;
+    getFileParents(fileId: string): Promise<any>;
+    updateRelationsFile({ relationsFileId, recommendationFileId }: {
+        relationsFileId: string;
+        recommendationFileId: string;
+    }): Promise<any>;
+    createRelationsFile({ vcFolderId }: {
+        vcFolderId: string;
+    }): Promise<any>;
     /**
      * Delete file by id
      * @param id