@cooperation/vc-storage 1.0.11 → 1.0.13

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,18 @@ export class CredentialEngine {
             throw error;
         }
     }
+    async findKeysAndDIDs() {
+        const keyPairs = (await this.storage.getAllFilesByType('KEYPAIRs'));
+        const DIDs = (await this.storage.getAllFilesByType('DIDs'));
+        if (DIDs.length === 0 || keyPairs.length === 0)
+            return null;
+        const keyPair = keyPairs[0].data;
+        const didDocument = DIDs[0].data.didDocument;
+        return {
+            didDocument,
+            keyPair,
+        };
+    }
     /**
      * Create a new DID with user metamask address as controller
      * @param walletrAddress
@@ -94,7 +107,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 +126,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 +173,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 +199,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 +228,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 = {
@@ -84,9 +95,8 @@ export class GoogleDriveStorage {
                 method: 'POST',
                 headers: {},
                 body: formData,
-                url: uploadUrl,
+                url: `${uploadUrl}&fields=id,parents`, // Request the file ID and parent folder IDs
             });
-            console.log('File uploaded successfully:', file.id);
             // 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 = {
@@ -96,112 +106,42 @@ export class GoogleDriveStorage {
             await this.fetcher({
                 method: 'POST',
                 url: permissionUrl,
-                headers: {
-                    'Content-Type': 'application/json',
-                },
+                headers: {},
                 body: JSON.stringify(permissionData),
             });
             console.log('Permission set to public for file:', file.id);
-            return { id: file.id };
+            console.log('Parent folder IDs:', file.parents);
+            return file;
         }
         catch (error) {
             console.error('Error uploading file or setting permission:', 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),
-            });
-            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, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${this.accessToken}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(body),
-            });
-            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;
-        }
-        catch (error) {
-            console.error('Error adding permission:', error.message);
-            throw error;
-        }
-    }
     /**
      * Get file from google drive by id
      * @param id
      * @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',
@@ -237,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);
@@ -248,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) => {
@@ -310,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
@@ -333,42 +256,64 @@ 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 = await Promise.all(vcSubfolders.map(async (folder) => {
+                    const files = await this.findFilesUnderFolder(folder.id);
+                    return Promise.all(files.map(async (file) => {
+                        return await this.retrieve(file.id);
+                    }));
+                }));
+                // 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);
@@ -400,6 +345,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

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

@@ -1,20 +1,39 @@
 import { KeyPair, DidDocument, FormDataI, RecommendationCredential, Credential, RecommendationFormDataI, VerifiableCredential } from '../../types/credential';
 /**
  * Create a DID document using the provided key pair.
- * @param {object} keyPair - The key pair used to create the DID document.
- * @returns {Promise<object>} The created DID document.
+ * @param {KeyPair} keyPair - The key pair used to create the DID document.
+ * @returns {Promise<DidDocument>} The created DID document.
+ * @throws Will throw an error if the DID document generation fails.
  */
 export declare const generateDIDSchema: (keyPair: KeyPair) => Promise<DidDocument>;
 /**
- * Generate an unsigned Verifiable Credential (VC)
- * @param {object} formData - The form data to include in the VC.
- * @param {string} issuerDid - The DID of the issuer.
- * @param {string} vcId - The ID of the credential generated by uuidv4()
- * @returns {Promise<object>} The created unsigned VC.
- * @throws Will throw an error if unsigned VC creation fails.
+ * Generate an unsigned Verifiable Credential (VC).
+ * Hashes the credential to create a unique ID.
+ * @param {FormDataI} params
+ * @param {string} params.FormData - The form dta to include in the VC.
+ * @param {string} params.issuerDid - The DID of the issuer.
+ * @returns {Credential} The created unsigned VC.
+ * @throws Will throw an error if the VC creation fails or if issuance date exceeds expiration date.
  */
-export declare function generateUnsignedVC(formData: FormDataI, issuerDid: string, vcId: string): Credential;
-export declare function generateUnsignedRecommendation(recommendation: RecommendationFormDataI, issuerDid: string): RecommendationCredential;
+export declare function generateUnsignedVC({ formData, issuerDid }: {
+    formData: FormDataI;
+    issuerDid: string;
+}): Credential;
+/**
+ * Generate an unsigned Recommendation Credential.
+ * Uses the hash of the VC to set the `id` for consistency.
+ * @param {object} params
+ * @param {VerifiableCredential} params.vc - The Verifiable Credential to base the recommendation on.
+ * @param {RecommendationFormDataI} params.recommendation - The recommendation form data.
+ * @param {string} params.issuerDid - The DID of the issuer.
+ * @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;
+    recommendation: RecommendationFormDataI;
+    issuerDid: string;
+}): RecommendationCredential;
 /**
  * Extracts the keypair from a Verifiable Credential
  * @param {Object} credential - The signed Verifiable Credential

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

@@ -1,15 +1,32 @@
 import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
+export type FileType = 'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR';
+interface SaveToGooglePropsI {
+    storage: GoogleDriveStorage;
+    data: any;
+    type: FileType;
+    vcId?: string;
+}
+export declare const getVCWithRecommendations: ({ vcId, storage }: {
+    vcId: string;
+    storage: GoogleDriveStorage;
+}) => Promise<{
+    vc: {
+        name: string;
+        data: any;
+        id: string;
+    };
+    recommendations: any[];
+    relationsFileId: any;
+}>;
 /**
- * keyFile name  = {uuid}-type-timestamp // we need that
- * vc.id = urn-uuid-{uuid} // we got that
  * Save data to Google Drive in the specified folder type.
  * @param {object} data - The data to save.
- * @param {'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR'} type - The type of data being saved.
+ * @param {FileType} data.type - The type of data being saved.
  * @returns {Promise<object>} - The file object saved to Google Drive.
- * @param {string} uuid - Optional unique identifier for the VC.
+ * @param {string} data.vcId - Optional unique identifier for the VC to link the recommendations.
  * @throws Will throw an error if the save operation fails.
  */
-export declare function saveToGoogleDrive(storage: GoogleDriveStorage, data: any, type: 'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR', uuid?: string): Promise<object>;
+export declare function saveToGoogleDrive({ storage, data, type }: SaveToGooglePropsI): Promise<any>;
 /**
  * Upload an image to Google Drive in the Credentials/MEDIAs folder.
  * @param {GoogleDriveStorage} storage - The GoogleDriveStorage instance.
@@ -22,3 +39,4 @@ export declare function uploadImageToGoogleDrive(storage: GoogleDriveStorage, im
 }>;
 export declare function generateViewLink(fileId: string): string;
 export declare function extractGoogleDriveFileId(url: string): string | null;
+export {};

package/dist/utils/credential.js

@@ -1,14 +1,28 @@
 import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+import crypto from 'crypto';
 import { v4 as uuidv4 } from 'uuid';
+/**
+ * Utility function to generate a hashed ID for a credential.
+ * Excludes the `id` field when hashing.
+ * @param {object} credential - The credential object to hash.
+ * @returns {string} The generated hashed ID.
+ */
+function generateHashedId(credential) {
+    // Exclude the `id` field from the hash
+    const credentialWithoutId = { ...credential, id: undefined };
+    const serialized = JSON.stringify(credentialWithoutId);
+    return crypto.createHash('sha256').update(serialized).digest('hex');
+}
 /**
  * Create a DID document using the provided key pair.
- * @param {object} keyPair - The key pair used to create the DID document.
- * @returns {Promise<object>} The created DID document.
+ * @param {KeyPair} keyPair - The key pair used to create the DID document.
+ * @returns {Promise<DidDocument>} The created DID document.
+ * @throws Will throw an error if the DID document generation fails.
  */
 export const generateDIDSchema = async (keyPair) => {
     try {
         const DID = keyPair.controller;
-        const didDocument = {
+        return {
             '@context': ['https://www.w3.org/ns/did/v1'],
             id: DID,
             publicKey: [
@@ -32,7 +46,6 @@ export const generateDIDSchema = async (keyPair) => {
                 },
             ],
         };
-        return didDocument;
     }
     catch (error) {
         console.error('Error creating DID document:', error);
@@ -40,117 +53,126 @@ export const generateDIDSchema = async (keyPair) => {
     }
 };
 /**
- * Generate an unsigned Verifiable Credential (VC)
- * @param {object} formData - The form data to include in the VC.
- * @param {string} issuerDid - The DID of the issuer.
- * @param {string} vcId - The ID of the credential generated by uuidv4()
- * @returns {Promise<object>} The created unsigned VC.
- * @throws Will throw an error if unsigned VC creation fails.
+ * Generate an unsigned Verifiable Credential (VC).
+ * Hashes the credential to create a unique ID.
+ * @param {FormDataI} params
+ * @param {string} params.FormData - The form dta to include in the VC.
+ * @param {string} params.issuerDid - The DID of the issuer.
+ * @returns {Credential} The created unsigned VC.
+ * @throws Will throw an error if the VC creation fails or if issuance date exceeds expiration date.
  */
-export function generateUnsignedVC(formData, issuerDid, vcId) {
-    try {
-        const issuanceDate = new Date().toISOString();
-        if (issuanceDate > formData.expirationDate)
-            throw Error('issuanceDate cannot be after expirationDate');
-        const unsignedCredential = {
-            '@context': [
-                'https://www.w3.org/2018/credentials/v1',
-                'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
-                {
-                    duration: 'https://schema.org/duration',
-                    fullName: 'https://schema.org/name',
-                    portfolio: 'https://schema.org/portfolio',
-                    evidenceLink: 'https://schema.org/evidenceLink',
-                    evidenceDescription: 'https://schema.org/evidenceDescription',
-                    credentialType: 'https://schema.org/credentialType',
-                },
-            ],
-            id: `urn:uuid:${vcId}`, //! i want this uuid to be in the condition where vcId part == keypair file name which is like this `${uuid ? uuid + '_' : ''}${type}_${timestamp}.json`,
-            type: ['VerifiableCredential', 'OpenBadgeCredential'],
-            issuer: {
-                id: issuerDid,
-                type: ['Profile'],
+export function generateUnsignedVC({ formData, issuerDid }) {
+    const issuanceDate = new Date().toISOString();
+    if (issuanceDate > formData.expirationDate)
+        throw new Error('issuanceDate cannot be after expirationDate');
+    const unsignedCredential = {
+        '@context': [
+            'https://www.w3.org/2018/credentials/v1',
+            'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
+            {
+                duration: 'https://schema.org/duration',
+                fullName: 'https://schema.org/name',
+                portfolio: 'https://schema.org/portfolio',
+                evidenceLink: 'https://schema.org/evidenceLink',
+                evidenceDescription: 'https://schema.org/evidenceDescription',
+                credentialType: 'https://schema.org/credentialType',
             },
-            issuanceDate,
-            expirationDate: formData.expirationDate,
-            credentialSubject: {
-                type: ['AchievementSubject'],
-                name: formData.fullName,
-                portfolio: formData.portfolio,
-                evidenceLink: formData.evidenceLink,
-                evidenceDescription: formData.achievementDescription,
-                duration: formData.duration,
-                credentialType: formData.credentialType,
-                achievement: [
-                    {
-                        id: `urn:uuid:${uuidv4()}`,
-                        type: ['Achievement'],
-                        criteria: {
-                            narrative: formData.criteriaNarrative,
-                        },
-                        description: formData.achievementDescription,
-                        name: formData.achievementName,
-                        image: formData.evidenceLink
-                            ? {
-                                id: formData.evidenceLink,
-                                type: 'Image',
-                            }
-                            : undefined,
-                    },
-                ],
-            },
-        };
-        return unsignedCredential;
-    }
-    catch (error) {
-        console.error('Error creating unsigned VC', error);
-        throw error;
-    }
-}
-export function generateUnsignedRecommendation(recommendation, issuerDid) {
-    try {
-        const issuanceDate = new Date().toISOString();
-        if (issuanceDate > recommendation.expirationDate)
-            throw Error('issuanceDate cannot be after expirationDate');
-        const unsignedRecommendation = {
-            '@context': [
-                'https://www.w3.org/2018/credentials/v1',
-                'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
+        ],
+        id: '', // Will be set after hashing
+        type: ['VerifiableCredential', 'OpenBadgeCredential'],
+        issuer: {
+            id: issuerDid,
+            type: ['Profile'],
+        },
+        issuanceDate,
+        expirationDate: formData.expirationDate,
+        credentialSubject: {
+            type: ['AchievementSubject'],
+            name: formData.fullName,
+            portfolio: formData.portfolio.map((item) => ({
+                '@type': 'schema:CreativeWork',
+                name: item.name,
+                url: item.url,
+            })),
+            evidenceLink: formData.evidenceLink,
+            evidenceDescription: formData.achievementDescription,
+            duration: formData.duration,
+            credentialType: formData.credentialType,
+            achievement: [
                 {
-                    howKnow: 'https://schema.org/howKnow',
-                    recommendationText: 'https://schema.org/recommendationText',
-                    qualifications: 'https://schema.org/qualifications',
-                    explainAnswer: 'https://schema.org/explainAnswer',
-                    portfolio: 'https://schema.org/portfolio',
+                    id: `urn:uuid:${uuidv4()}`,
+                    type: ['Achievement'],
+                    criteria: {
+                        narrative: formData.criteriaNarrative,
+                    },
+                    description: formData.achievementDescription,
+                    name: formData.achievementName,
+                    image: formData.evidenceLink
+                        ? {
+                            id: formData.evidenceLink,
+                            type: 'Image',
+                        }
+                        : undefined,
                 },
             ],
-            id: `urn:uuid:${uuidv4()}`, // Unique identifier for the recommendation
-            type: ['VerifiableCredential', 'https://schema.org/RecommendationCredential'], // Use a fully qualified URI for 'RecommendationCredential'
-            issuer: {
-                id: issuerDid,
-                type: ['Profile'],
-            },
-            issuanceDate,
-            expirationDate: recommendation.expirationDate,
-            credentialSubject: {
-                name: recommendation.fullName,
-                howKnow: recommendation.howKnow,
-                recommendationText: recommendation.recommendationText,
-                qualifications: recommendation.qualifications,
-                explainAnswer: recommendation.explainAnswer,
-                portfolio: recommendation.portfolio.map((item) => ({
-                    name: item.name,
-                    url: item.url,
-                })),
+        },
+    };
+    // Generate the hashed ID
+    unsignedCredential.id = 'urn:' + generateHashedId(unsignedCredential);
+    return unsignedCredential;
+}
+/**
+ * Generate an unsigned Recommendation Credential.
+ * Uses the hash of the VC to set the `id` for consistency.
+ * @param {object} params
+ * @param {VerifiableCredential} params.vc - The Verifiable Credential to base the recommendation on.
+ * @param {RecommendationFormDataI} params.recommendation - The recommendation form data.
+ * @param {string} params.issuerDid - The DID of the issuer.
+ * @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);
+    const issuanceDate = new Date().toISOString();
+    if (issuanceDate > recommendation.expirationDate)
+        throw new Error('issuanceDate cannot be after expirationDate');
+    const unsignedRecommendation = {
+        '@context': [
+            'https://www.w3.org/2018/credentials/v1',
+            'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
+            {
+                howKnow: 'https://schema.org/howKnow',
+                recommendationText: 'https://schema.org/recommendationText',
+                qualifications: 'https://schema.org/qualifications',
+                explainAnswer: 'https://schema.org/explainAnswer',
+                portfolio: 'https://schema.org/portfolio',
             },
-        };
-        console.log('Successfully created Unsigned Recommendation', unsignedRecommendation);
-        return unsignedRecommendation;
-    }
-    catch (error) {
-        console.error('Error creating unsigned recommendation', error);
-        throw error;
-    }
+        ],
+        id: '', // Will be set after hashing VC
+        type: ['VerifiableCredential', 'https://schema.org/RecommendationCredential'],
+        issuer: {
+            id: issuerDid,
+            type: ['Profile'],
+        },
+        issuanceDate,
+        expirationDate: recommendation.expirationDate,
+        credentialSubject: {
+            name: recommendation.fullName,
+            howKnow: recommendation.howKnow,
+            recommendationText: recommendation.recommendationText,
+            qualifications: recommendation.qualifications,
+            explainAnswer: recommendation.explainAnswer,
+            portfolio: recommendation.portfolio.map((item) => ({
+                name: item.name,
+                url: item.url,
+            })),
+        },
+    };
+    // Use the VC's hashed ID for the Recommendation's ID
+    unsignedRecommendation.id = vc.data.id;
+    return unsignedRecommendation;
 }
 /**
  * Extracts the keypair from a Verifiable Credential

package/dist/utils/google.js

@@ -1,18 +1,29 @@
+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 };
+};
 /**
- * keyFile name  = {uuid}-type-timestamp // we need that
- * vc.id = urn-uuid-{uuid} // we got that
  * Save data to Google Drive in the specified folder type.
  * @param {object} data - The data to save.
- * @param {'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR'} type - The type of data being saved.
+ * @param {FileType} data.type - The type of data being saved.
  * @returns {Promise<object>} - The file object saved to Google Drive.
- * @param {string} uuid - Optional unique identifier for the VC.
+ * @param {string} data.vcId - Optional unique identifier for the VC to link the recommendations.
  * @throws Will throw an error if the save operation fails.
  */
-export async function saveToGoogleDrive(storage, data, type, uuid) {
+export async function saveToGoogleDrive({ storage, data, type }) {
     try {
-        const timestamp = Date.now();
         const fileData = {
-            fileName: `${uuid ? uuid + '_' : ''}${type}_${timestamp}.json`,
+            fileName: type === 'VC' ? 'VC' : `${type}-${Date.now()}`,
             mimeType: 'application/json',
             body: JSON.stringify(data),
         };
@@ -24,34 +35,31 @@ export async function saveToGoogleDrive(storage, data, type, uuid) {
         let credentialsFolderId;
         if (!credentialsFolder) {
             credentialsFolderId = await storage.createFolder('Credentials');
-            console.log('Created Credentials folder with ID:', credentialsFolderId);
         }
         else {
             credentialsFolderId = credentialsFolder.id;
-            console.log('Found Credentials folder with ID:', credentialsFolderId);
         }
         // Get subfolders within the "Credentials" folder
         const subfolders = await storage.findFolders(credentialsFolderId);
-        console.log(`Subfolders in Credentials (ID: ${credentialsFolderId}):`, subfolders);
         // Find or create the specific subfolder (DIDs or VCs)
         let typeFolder = subfolders.find((f) => f.name === `${type}s`);
         let typeFolderId;
         if (!typeFolder) {
             typeFolderId = await storage.createFolder(`${type}s`, credentialsFolderId);
-            console.log(`Created ${type}s folder with ID:`, typeFolderId);
         }
         else {
             typeFolderId = typeFolder.id;
-            console.log(`Found ${type} files:`, await storage.findLastFile(typeFolderId));
-            console.log(`Found ${type}s folder with ID:`, typeFolderId);
+        }
+        if (type === 'VC') {
+            // save the data in Credentials/VCs/VC-timestamp/vc.json
+            const vcFolderId = await storage.createFolder(`${fileData.fileName}-${Date.now()}`, typeFolderId);
+            const file = await storage.saveFile({ data: fileData, folderId: vcFolderId });
+            console.log(`File uploaded: ${file?.id} under ${fileData.fileName} folder in VCs folder`);
+            return file;
         }
         // Save the file in the specific subfolder
-        const file = await storage.save(fileData, typeFolderId);
+        const file = await storage.saveFile({ data: fileData, folderId: typeFolderId });
         console.log(`File uploaded: ${file?.id} under ${type}s with ID ${typeFolderId} folder in Credentials folder`);
-        if (file && file.id) {
-            console.log('Sharing file with second user...');
-            await storage.addCommenterRoleToFile(file.id);
-        }
         return file;
     }
     catch (error) {
@@ -92,8 +100,11 @@ export async function uploadImageToGoogleDrive(storage, imageFile) {
             mimeType: imageFile.type,
             body: imageFile,
         };
-        // Save the image in the "MEDIAs" folder
-        const uploadedImage = await storage.save(imageData, mediasFolderId);
+        // SaveFile the image in the "MEDIAs" folder
+        const uploadedImage = await storage.saveFile({
+            data: imageData,
+            folderId: mediasFolderId,
+        });
         console.log(`Image uploaded: ${uploadedImage?.id} to MEDIAs folder in Credentials`);
         return uploadedImage;
     }

package/dist/utils/presentation.js

@@ -1,6 +1,3 @@
-import { CredentialEngine } from '../models/CredentialEngine.js';
-import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
-import { extractGoogleDriveFileId } from './google.js';
 /**
  * Create and sign a Verifiable Presentation (VP) from a given Verifiable Credential (VC) file and any associated recommendations.
  * @param {string} accessTokens - The access tokens for the user.
@@ -14,32 +11,32 @@ export const createAndSignVerifiablePresentation = async (accessTokens, vcFileId
         return null;
     }
     try {
-        const storage = new GoogleDriveStorage(accessTokens);
-        const engine = new CredentialEngine(accessTokens);
-        // Fetch Verifiable Credential (VC)
-        const verifiableCredential = await storage.retrieve(vcFileId);
-        if (!verifiableCredential) {
-            throw new Error('Verifiable Credential not found.');
-        }
-        // Fetch VC comments (potential recommendations)
-        const verifiableCredentialComments = await storage.getFileComments(vcFileId);
-        let recommendations = [];
-        // Extract recommendations from comments if present
-        if (verifiableCredentialComments.length > 0) {
-            for (const comment of verifiableCredentialComments) {
-                console.log('🚀 ~ createAndSignVerifiablePresentation ~ comment', comment);
-                const recommendationFile = await storage.retrieve(extractGoogleDriveFileId(comment.content));
-                console.log('🚀 ~ createAndSignVerifiablePresentation ~ recommendationFile', recommendationFile);
-                if (recommendationFile) {
-                    recommendations.push(recommendationFile);
-                }
-            }
-        }
-        // Create Verifiable Presentation (VP) with the retrieved VC
-        const presentation = await engine.createPresentation([verifiableCredential.data, ...recommendations]); //! do not edit the array order!!
-        // Use the key pair to sign the presentation
-        const signedPresentation = await engine.signPresentation(presentation);
-        return { signedPresentation };
+        // const storage = new GoogleDriveStorage(accessTokens);
+        // const engine = new CredentialEngine(accessTokens);
+        // // Fetch Verifiable Credential (VC)
+        // const verifiableCredential = await storage.retrieve(vcFileId);
+        // if (!verifiableCredential) {
+        // 	throw new Error('Verifiable Credential not found.');
+        // }
+        // // Fetch VC comments (potential recommendations)
+        // const verifiableCredentialComments = await storage.getFileComments(vcFileId);
+        // let recommendations: object[] = [];
+        // // Extract recommendations from comments if present
+        // if (verifiableCredentialComments.length > 0) {
+        // 	for (const comment of verifiableCredentialComments) {
+        // 		console.log('🚀 ~ createAndSignVerifiablePresentation ~ comment', comment);
+        // 		const recommendationFile = await storage.retrieve(extractGoogleDriveFileId(comment.content));
+        // 		console.log('🚀 ~ createAndSignVerifiablePresentation ~ recommendationFile', recommendationFile);
+        // 		if (recommendationFile) {
+        // 			recommendations.push(recommendationFile);
+        // 		}
+        // 	}
+        // }
+        // // Create Verifiable Presentation (VP) with the retrieved VC
+        // const presentation = await engine.createPresentation([verifiableCredential.data, ...recommendations]); //! do not edit the array order!!
+        // // Use the key pair to sign the presentation
+        // const signedPresentation = await engine.signPresentation(presentation);
+        // return {};
     }
     catch (error) {
         console.error('Error during Verifiable Presentation creation and signing:', error);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.11",
+	"version": "1.0.13",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -21,6 +21,7 @@
 		"@digitalbazaar/ed25519-verification-key-2020": "^4.1.0",
 		"@digitalbazaar/vc": "^6.3.0",
 		"ethers": "^6.13.2",
+		"ts-node": "^10.9.2",
 		"tsc": "^2.0.4",
 		"uuid": "^10.0.0"
 	},

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

@@ -1,10 +0,0 @@
-import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
-/**
- * Save data to Google Drive in the specified folder type.
- * @param {object} data - The data to save.
- * @param {'VC' | 'DID' | 'UnsignedVC'} type - The type of data being saved.
- * @returns {Promise<object>} - The file object saved to Google Drive.
- * @throws Will throw an error if the save operation fails.
- */
-export declare function saveToGoogleDrive(storage: GoogleDriveStorage, data: any, type: 'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION'): Promise<object>;
-export declare function generateViewLink(fileId: string): string;

package/dist/utils/saveToGoogle.js

@@ -1,65 +0,0 @@
-/**
- * Save data to Google Drive in the specified folder type.
- * @param {object} data - The data to save.
- * @param {'VC' | 'DID' | 'UnsignedVC'} type - The type of data being saved.
- * @returns {Promise<object>} - The file object saved to Google Drive.
- * @throws Will throw an error if the save operation fails.
- */
-export async function saveToGoogleDrive(storage, data, type) {
-    try {
-        const timestamp = Date.now();
-        const fileData = {
-            fileName: `${type}-${timestamp}.json`,
-            mimeType: 'application/json',
-            body: JSON.stringify(data),
-        };
-        // Get all root folders
-        const rootFolders = await storage.findFolders();
-        console.log('Root folders:', rootFolders);
-        // Find or create the "Credentials" folder
-        let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
-        let credentialsFolderId;
-        if (!credentialsFolder) {
-            credentialsFolderId = await storage.createFolder('Credentials');
-            console.log('Created Credentials folder with ID:', credentialsFolderId);
-        }
-        else {
-            credentialsFolderId = credentialsFolder.id;
-            console.log('Found Credentials folder with ID:', credentialsFolderId);
-        }
-        // Get subfolders within the "Credentials" folder
-        const subfolders = await storage.findFolders(credentialsFolderId);
-        console.log(`Subfolders in Credentials (ID: ${credentialsFolderId}):`, subfolders);
-        // Find or create the specific subfolder (DIDs or VCs)
-        let typeFolder = subfolders.find((f) => f.name === `${type}s`);
-        let typeFolderId;
-        if (!typeFolder) {
-            typeFolderId = await storage.createFolder(`${type}s`, credentialsFolderId);
-            console.log(`Created ${type}s folder with ID:`, typeFolderId);
-        }
-        else {
-            typeFolderId = typeFolder.id;
-            console.log(`Found ${type} files:`, await storage.findLastFile(typeFolderId));
-            console.log(`Found ${type}s folder with ID:`, typeFolderId);
-        }
-        // Save the file in the specific subfolder
-        const file = await storage.save(fileData, typeFolderId);
-        console.log(`File uploaded: ${file?.id} under ${type}s with ID ${typeFolderId} folder in Credentials folder`);
-        if (file && file.id) {
-            console.log('Sharing file with second user...');
-            await storage.addCommenterRoleToFile(file.id);
-        }
-        return file;
-    }
-    catch (error) {
-        console.error('Error saving to Google Drive:', error);
-        throw error;
-    }
-}
-export function generateViewLink(fileId) {
-    if (!fileId) {
-        throw new Error('File ID is required to generate a view link.');
-    }
-    // Construct the view URL based on the file ID
-    return `https://drive.google.com/file/d/${fileId}/view`;
-}