@cooperation/vc-storage 1.0.34 → 1.0.40

package/README.md

@@ -1,6 +1,6 @@
 # @cooperation/vc-storage
 
-**Version**: 1.0.0
+**Version**: 1.0.35
 
 ## Overview
 

package/app.config.js

@@ -0,0 +1 @@
+export const WAS_BASE_URL = 'http://localhost:4444';

package/dist/index.js

@@ -1,6 +1,8 @@
 export * from './models/GoogleDriveStorage.js';
 export * from './models/CredentialEngine.js';
 export * from './utils/google.js';
-export * from './utils/presentation.js';
 export * from './models/Resume.js';
 export * from './models/ResumeVC.js';
+export * from './models/WASStorage.js';
+export * from './utils/createWASSpace.js';
+export * from './utils/getOrCreateAppDID.js';

package/dist/models/CredentialEngine.js

@@ -126,7 +126,7 @@ export class CredentialEngine {
     }
     /**
      * Sign a Verifiable Credential (VC)
-     * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
+     * @param {'VC' | 'RECOMMENDATION' | 'EMPLOYMENT' | 'VOLUNTEERING' | 'PERFORMANCE_REVIEW'} 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.
@@ -269,7 +269,7 @@ export class CredentialEngine {
                 throw new Error('SEED environment variable not set. Cannot generate or use any DID.');
             }
             // Use deterministic keys from environment seed
-            const { getDidFromEnvSeed } = await import('../utils/decodedSeed');
+            const { getDidFromEnvSeed } = await import('../utils/decodedSeed.js');
             const result = await getDidFromEnvSeed(encodedSeed);
             keyPair = result.keyPair;
             didDocument = result.didDocument;

package/dist/models/GoogleDriveStorage.js

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

package/dist/models/Resume.js

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

package/dist/models/WASStorage.js

@@ -0,0 +1,71 @@
+import { StorageClient } from '@wallet.storage/fetch-client';
+import { WAS_BASE_URL } from '../../app.config.js';
+export class LCWStorage {
+    static storageClient;
+    signer;
+    zcap;
+    spaceId;
+    constructor({ signer, zcap, spaceId }) {
+        this.signer = signer;
+        this.zcap = zcap;
+        this.spaceId = spaceId;
+    }
+    getStorageClient() {
+        if (!LCWStorage.storageClient) {
+            LCWStorage.storageClient = new StorageClient(new URL(WAS_BASE_URL));
+        }
+        return LCWStorage.storageClient;
+    }
+    getResource(key) {
+        const space = this.getStorageClient().space({
+            signer: this.signer,
+            id: this.spaceId,
+        });
+        return space.resource(key);
+    }
+    async add(key, value) {
+        const resource = this.getResource(key);
+        const blob = new Blob([JSON.stringify(value)], {
+            type: 'application/json',
+        });
+        const res = await resource.put(blob, {
+            signer: this.signer,
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to add resource. Status: ${res.status}`);
+        }
+        return res;
+    }
+    async read(key) {
+        const resource = this.getResource(key);
+        const res = await resource.get({ signer: this.signer });
+        if (!res.ok) {
+            if (res.status === 404)
+                return null;
+            throw new Error(`Failed to read resource. Status: ${res.status}`);
+        }
+        return await res.json();
+    }
+    async update(key, value) {
+        return this.add(key, value); // Overwrite = update
+    }
+    async delete(key) {
+        const resource = this.getResource(key);
+        const res = await resource.delete({ signer: this.signer });
+        if (!res.ok && res.status !== 404) {
+            throw new Error(`Failed to delete resource. Status: ${res.status}`);
+        }
+        return true;
+    }
+    async list() {
+        // const space = this.getStorageClient().space({
+        //   signer: this.signer,
+        //   id: this.spaceId as `urn:uuid:${string}`,
+        // });
+        // const res = await space.resources().list({ signer: this.signer });
+        // if (!res.ok) {
+        //   throw new Error(`Failed to list resources. Status: ${res.status}`);
+        // }
+        // return await res.json(); // Should contain list of resource IDs or summaries
+    }
+}

package/dist/scripts/test-was.js

@@ -0,0 +1,61 @@
+import { Ed25519Signer } from '@did.coop/did-key-ed25519';
+import { v4 as uuidv4 } from 'uuid';
+import { LCWStorage } from '../models/WASStorage.js';
+import { StorageClient } from '@wallet.storage/fetch-client';
+import { WAS_BASE_URL } from '../../app.config.js';
+async function main() {
+    const appDidSigner = await Ed25519Signer.generate();
+    console.log('Signer:', appDidSigner);
+    const spaceUUID = uuidv4();
+    const spaceId = `urn:uuid:${spaceUUID}`;
+    console.log('Space ID:', spaceId);
+    const storage = new StorageClient(new URL(WAS_BASE_URL));
+    const space = storage.space({
+        signer: appDidSigner,
+        id: spaceId,
+    });
+    const spaceObject = {
+        id: spaceId,
+        controller: appDidSigner.id.split('#')[0],
+    };
+    console.log('Creating space with object:', spaceObject);
+    const spaceObjectBlob = new Blob([JSON.stringify(spaceObject)], { type: 'application/json' });
+    // Create the space
+    const response = await space.put(spaceObjectBlob, {
+        signer: appDidSigner,
+    });
+    console.log('🚀 ~ main ~ response:', response);
+    console.log('Space PUT response:', {
+        status: response.status,
+        ok: response.ok,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to initialize space. Status: ${response.status}`);
+    }
+    // Store the signer for future connections
+    const signerJson = await appDidSigner.toJSON();
+    console.log('Signer JSON:', signerJson);
+    const lcwStorage = new LCWStorage({ signer: appDidSigner, zcap: {}, spaceId });
+    const res = await lcwStorage.add('test', { test: 'test' });
+    if (res.ok) {
+        console.log('Record added successfully');
+    }
+    else {
+        console.error('Failed to add record');
+    }
+    const res2 = await lcwStorage.read('test');
+    if (res2) {
+        console.log('Record read successfully');
+    }
+    else {
+        console.error('Failed to read record');
+    }
+    const res3 = await lcwStorage.update('test', { test: 'test2' });
+    if (res3.ok) {
+        console.log('Record updated successfully');
+    }
+    else {
+        console.error('Failed to update record');
+    }
+}
+main();

package/dist/types/index.d.ts

@@ -1,6 +1,8 @@
 export * from './models/GoogleDriveStorage.js';
 export * from './models/CredentialEngine.js';
 export * from './utils/google.js';
-export * from './utils/presentation.js';
 export * from './models/Resume.js';
 export * from './models/ResumeVC.js';
+export * from './models/WASStorage.js';
+export * from './utils/createWASSpace.js';
+export * from './utils/getOrCreateAppDID.js';

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

@@ -50,7 +50,7 @@ export declare class CredentialEngine {
     }>;
     /**
      * Sign a Verifiable Credential (VC)
-     * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
+     * @param {'VC' | 'RECOMMENDATION' | 'EMPLOYMENT' | 'VOLUNTEERING' | 'PERFORMANCE_REVIEW'} 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.

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

@@ -3,70 +3,64 @@ type FileType = 'KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs' | '
  * @class GoogleDriveStorage
  * @description Class to interact with Google Drive API
  * @param accessToken - Access token to authenticate with Google Drive API
- * @method createFolder - Create a new folder in Google Drive
- * @method save - Save data to Google Drive
- * @method addCommentToFile - Add a comment to a file in Google Drive
- * @method addCommenterRoleToFile - Add commenter role to a file in Google Drive
+ * @method saveFile - Save a file to Google Drive
  * @method retrieve - Retrieve a file from Google Drive
- * @method findFolders - Find folders in Google Drive
- * @method findLastFile - Find the last file in a folder
- * @method getAllVCs - Get all verifiable credentials from Google Drive
- * @method getAllSessions - Get all sessions from Google Drive
+ * @method createFolder - Create a new folder in Google Drive
+ * @method getOrCreateMediaFolder - Get the ID of the MEDIAs folder
+ * @method uploadBinaryFile - Upload a binary file to Google Drive
+ * @method updateFileData - Update the data of a file
+ * @method updateRelationsFile - Update the relations file
  * @method delete - Delete a file from Google Drive
+ * @method checkEmailExists - Check if an email VC exists and return its content
+ * @method findFolders - Find folders in Google Drive
+ * @method findFolderFiles - Find files in a folder
  */
 export declare class GoogleDriveStorage {
     private accessToken;
-    folderCache: any;
-    private fileIdsCache;
-    private updateFileIdsJson;
+    static folderCache: any;
+    private static fileIdsCache;
     constructor(accessToken: string);
+    private updateFileIdsJson;
     private fetcher;
     private getFileContent;
     private searchFiles;
+    private getOrCreateMediaFolder;
+    findFolderFiles(folderId: string): Promise<any[]>;
     createFolder({ folderName, parentFolderId }: {
         folderName: string;
         parentFolderId: string;
     }): Promise<any>;
-    getMediaFolderId(): Promise<any>;
+    /**
+     * Get the ID of the MEDIAs folder (public wrapper for getOrCreateMediaFolder)
+     * @returns The folder ID for the MEDIAs folder
+     */
+    getMediaFolderId(): Promise<string>;
     uploadBinaryFile({ file }: {
         file: File;
     }): Promise<any>;
-    saveFile({ data, folderId }: {
+    saveFile({ data, folderId, fileId }: {
         data: any;
-        folderId: string;
+        folderId?: string;
+        fileId?: string;
     }): Promise<any>;
-    /**
-     * Get file from google drive by id
-     * @param id
-     * @returns file content
-     */
     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[]>;
-    /**
-     * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
-     * @param type
-     * @returns
-     */
     getAllFilesByType(type: FileType): Promise<any[]>;
+    updateFileData(fileId: string, data: {
+        fileName: string;
+    }): Promise<any>;
     /**
-     * Update the name of a file in Google Drive
+     * Update the content of an existing file in Google Drive
      * @param fileId - The ID of the file to update
-     * @param newFileName - The new name for the file
-     * @returns The updated file metadata, including the new name
+     * @param data - The new content for the file
+     * @returns The updated file metadata
      */
-    updateFileName(fileId: string, newFileName: string): Promise<any>;
-    findFileByName(name: string): Promise<any>;
-    findFilesUnderFolder(folderId: string): Promise<any[]>;
-    updateFileData(fileId: string, data: {
-        fileName: string;
+    updateFileContent({ fileId, data }: {
+        fileId: string;
+        data: any;
     }): Promise<any>;
     getFileParents(fileId: string): Promise<any>;
     updateRelationsFile({ relationsFileId, recommendationFileId }: {
@@ -76,25 +70,7 @@ export declare class GoogleDriveStorage {
     createRelationsFile({ vcFolderId }: {
         vcFolderId: string;
     }): Promise<any>;
-    updateResumeRelation({ authorFolderId, draftFileId, signedFileId, }: {
-        authorFolderId: string;
-        draftFileId: string;
-        signedFileId: string;
-    }): Promise<any>;
-    /**
-     * Delete file by id
-     * @param id
-     * @returns
-     */
     delete(id: string): Promise<any>;
-    update(fileId: string, data: any): Promise<any>;
-    getFileIdsFromAppDataFolder(): Promise<any>;
-    getAllFilesData(): Promise<any>;
-    /**
-     * Check if an email VC exists and return its content
-     * @param email - The email address to check
-     * @returns {Promise<{data: any, id: string} | null>} - The email VC content and ID if exists, null otherwise
-     */
     checkEmailExists(email: string): Promise<{
         data: any;
         id: string;

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

@@ -1,4 +1,4 @@
-import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+import { GoogleDriveStorage } from './GoogleDriveStorage';
 export declare const resumeFolderTypes: {
     root: string;
     nonSigned: string;
@@ -14,9 +14,10 @@ export declare class StorageHandler {
 }
 export declare class Resume extends StorageHandler {
     constructor(storage: GoogleDriveStorage);
-    saveResume({ resume, type }: {
+    saveResume({ resume, type, id }: {
         resume: any;
         type: 'sign' | 'unsigned';
+        id?: string;
     }): Promise<any>;
     find(): Promise<{
         signed: any[];

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

@@ -0,0 +1,30 @@
+export declare class LCWStorage {
+    private static storageClient;
+    private signer;
+    private zcap;
+    private spaceId;
+    constructor({ signer, zcap, spaceId }: {
+        signer: any;
+        zcap: any;
+        spaceId: string;
+    });
+    private getStorageClient;
+    private getResource;
+    add(key: string, value: any): Promise<{
+        ok: boolean;
+        headers: [string, string][];
+        status: number;
+        blob(): Promise<import("buffer").Blob>;
+        json(): Promise<unknown>;
+    }>;
+    read(key: string): Promise<unknown>;
+    update(key: string, value: any): Promise<{
+        ok: boolean;
+        headers: [string, string][];
+        status: number;
+        blob(): Promise<import("buffer").Blob>;
+        json(): Promise<unknown>;
+    }>;
+    delete(key: string): Promise<boolean>;
+    list(): Promise<void>;
+}

package/dist/types/scripts/test-was.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import { Ed25519Signer } from '@did.coop/did-key-ed25519';
+/**
+ * Create a new WAS space
+ * @returns {Promise<{ signer: InstanceType<typeof Ed25519Signer>; spaceId: `urn:uuid:${string}` }>}
+ */
+export declare function createSpace(): Promise<{
+    signer: InstanceType<typeof Ed25519Signer>;
+    spaceId: `urn:uuid:${string}`;
+}>;

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

@@ -1,4 +1,4 @@
-import { KeyPair, DidDocument, FormDataI, RecommendationCredential, Credential, RecommendationFormDataI, VerifiableCredential, EmploymentFormDataI, VolunteeringFormDataI, PerformanceReviewFormDataI } from '../../types/credential';
+import { KeyPair, DidDocument, FormDataI, RecommendationCredential, Credential, RecommendationFormDataI, VerifiableCredential, EmploymentFormDataI, VolunteeringFormDataI, PerformanceReviewFormDataI } from '../../types';
 /**
  * Create a DID document using the provided key pair.
  * @param {KeyPair} keyPair - The key pair used to create the DID document.

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

@@ -0,0 +1,11 @@
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+export interface AppInstanceKeyPair {
+    controller: string;
+    id: string;
+    publicKeyMultibase: string;
+    privateKeyMultibase: string;
+}
+export declare function getOrCreateAppInstanceDid(): Promise<{
+    did: string;
+    keyPair: Ed25519VerificationKey2020;
+}>;

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

@@ -1,4 +1,4 @@
-import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
+import { GoogleDriveStorage } from '../models/GoogleDriveStorage';
 export type FileType = 'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR';
 interface SaveToGooglePropsI {
     storage: GoogleDriveStorage;

package/dist/utils/createWASSpace.js

@@ -0,0 +1,27 @@
+import { StorageClient } from '@wallet.storage/fetch-client';
+import { Ed25519Signer } from '@did.coop/did-key-ed25519';
+import { v4 as uuidv4 } from 'uuid';
+import { WAS_BASE_URL } from '../../app.config.js';
+/**
+ * Create a new WAS space
+ * @returns {Promise<{ signer: InstanceType<typeof Ed25519Signer>; spaceId: `urn:uuid:${string}` }>}
+ */
+export async function createSpace() {
+    const signer = await Ed25519Signer.generate();
+    const controller = signer.id.split('#')[0];
+    const spaceUUID = uuidv4();
+    const spaceId = `urn:uuid:${spaceUUID}`;
+    const client = new StorageClient(new URL(WAS_BASE_URL));
+    const space = client.space({ signer, id: spaceId });
+    const spaceObject = {
+        id: spaceId,
+        controller,
+    };
+    const blob = new Blob([JSON.stringify(spaceObject)], { type: 'application/json' });
+    const res = await space.put(blob, { signer });
+    if (!res.ok) {
+        throw new Error(`Failed to initialize WAS space. Status: ${res.status}`);
+    }
+    console.log('✅ Provisioned and saved new WAS space');
+    return { signer, spaceId };
+}

package/dist/utils/credential.js

@@ -177,10 +177,7 @@ export function generateUnsignedRecommendation({ vcId, recommendation, issuerDid
 export function generateUnsignedEmployment({ formData, issuerDid }) {
     const issuanceDate = new Date().toISOString();
     const unsignedCredential = {
-        '@context': [
-            'https://www.w3.org/2018/credentials/v1',
-            employmentCredentialContext['@context'],
-        ],
+        '@context': ['https://www.w3.org/2018/credentials/v1', employmentCredentialContext['@context']],
         id: '',
         type: ['VerifiableCredential', 'EmploymentCredential'],
         issuer: { id: issuerDid, type: ['Profile'] },
@@ -192,7 +189,7 @@ export function generateUnsignedEmployment({ formData, issuerDid }) {
             credentialName: formData.credentialName,
             credentialDuration: formData.credentialDuration,
             credentialDescription: formData.credentialDescription,
-            portfolio: formData.portfolio.map(item => ({ name: item.name, url: item.url })),
+            portfolio: formData.portfolio.map((item) => ({ name: item.name, url: item.url })),
             evidenceLink: formData.evidenceLink,
             evidenceDescription: formData.evidenceDescription,
             company: formData.company,
@@ -208,10 +205,7 @@ export function generateUnsignedEmployment({ formData, issuerDid }) {
 export function generateUnsignedVolunteering({ formData, issuerDid }) {
     const issuanceDate = new Date().toISOString();
     const unsignedCredential = {
-        '@context': [
-            'https://www.w3.org/2018/credentials/v1',
-            volunteeringCredentialContext['@context'],
-        ],
+        '@context': ['https://www.w3.org/2018/credentials/v1', volunteeringCredentialContext['@context']],
         id: '',
         type: ['VerifiableCredential', 'VolunteeringCredential'],
         issuer: { id: issuerDid, type: ['Profile'] },
@@ -223,10 +217,10 @@ export function generateUnsignedVolunteering({ formData, issuerDid }) {
             volunteerWork: formData.volunteerWork,
             volunteerOrg: formData.volunteerOrg,
             volunteerDescription: formData.volunteerDescription,
-            skillsGained: formData.skillsGained ? formData.skillsGained.split(',').map(s => s.trim()) : undefined,
+            skillsGained: formData.skillsGained ? formData.skillsGained.split(',').map((s) => s.trim()) : undefined,
             duration: formData.duration,
             volunteerDates: formData.volunteerDates,
-            portfolio: formData.portfolio.map(item => ({ name: item.name, url: item.url })),
+            portfolio: formData.portfolio.map((item) => ({ name: item.name, url: item.url })),
             evidenceLink: formData.evidenceLink,
             evidenceDescription: formData.evidenceDescription,
         },
@@ -240,10 +234,7 @@ export function generateUnsignedVolunteering({ formData, issuerDid }) {
 export function generateUnsignedPerformanceReview({ formData, issuerDid }) {
     const issuanceDate = new Date().toISOString();
     const unsignedCredential = {
-        '@context': [
-            'https://www.w3.org/2018/credentials/v1',
-            performanceReviewCredentialContext['@context'],
-        ],
+        '@context': ['https://www.w3.org/2018/credentials/v1', performanceReviewCredentialContext['@context']],
         id: '',
         type: ['VerifiableCredential', 'PerformanceReviewCredential'],
         issuer: { id: issuerDid, type: ['Profile'] },
@@ -266,7 +257,7 @@ export function generateUnsignedPerformanceReview({ formData, issuerDid }) {
             overallRating: formData.overallRating,
             reviewComments: formData.reviewComments,
             goalsNext: formData.goalsNext,
-            portfolio: formData.portfolio.map(item => ({ name: item.name, url: item.url })),
+            portfolio: formData.portfolio.map((item) => ({ name: item.name, url: item.url })),
             evidenceLink: formData.evidenceLink,
             evidenceDescription: formData.evidenceDescription,
         },

package/dist/utils/getOrCreateAppDID.js

@@ -0,0 +1,22 @@
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+const LOCAL_STORAGE_KEY = 'AppInstanceDID';
+export async function getOrCreateAppInstanceDid() {
+    const stored = localStorage.getItem(LOCAL_STORAGE_KEY);
+    if (stored) {
+        const parsed = JSON.parse(stored);
+        const keyPair = await Ed25519VerificationKey2020.from(parsed);
+        return { did: keyPair.controller, keyPair };
+    }
+    const keyPair = await Ed25519VerificationKey2020.generate();
+    keyPair.controller = `did:key:${keyPair.publicKeyMultibase}`;
+    keyPair.id = `${keyPair.controller}#${keyPair.publicKeyMultibase}`;
+    keyPair.revoked = false;
+    const did = keyPair.controller;
+    localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify({
+        controller: keyPair.controller,
+        id: keyPair.id,
+        publicKeyMultibase: keyPair.publicKeyMultibase,
+        privateKeyMultibase: keyPair.privateKeyMultibase,
+    }));
+    return { did, keyPair };
+}

package/dist/utils/google.js

@@ -1,7 +1,7 @@
 export const getVCWithRecommendations = async ({ vcId, storage }) => {
     try {
         const vcFolderId = await storage.getFileParents(vcId);
-        const files = await storage.findFilesUnderFolder(vcFolderId);
+        const files = await storage.findFolderFiles(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;

package/package.json

@@ -1,12 +1,13 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.34",
+	"version": "1.0.40",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
 	"files": [
-		"dist"
+		"dist",
+		"app.config.js"
 	],
 	"scripts": {
 		"build": "tsc",
@@ -16,10 +17,12 @@
 	"author": "cooperation",
 	"license": "ISC",
 	"dependencies": {
+		"@did.coop/did-key-ed25519": "^0.0.13",
 		"@digitalbazaar/did-method-key": "^5.2.0",
 		"@digitalbazaar/ed25519-signature-2020": "^5.4.0",
 		"@digitalbazaar/ed25519-verification-key-2020": "^4.1.0",
 		"@digitalbazaar/vc": "^6.3.0",
+		"@wallet.storage/fetch-client": "^1.2.0",
 		"add": "^2.0.6",
 		"bnid": "^3.0.0",
 		"crypto-js": "^4.2.0",
@@ -37,7 +40,7 @@
 		"@types/jest": "^29.5.14",
 		"@types/uuid": "^10.0.0",
 		"babel-jest": "^29.7.0",
-		"typescript": "^5.8.2",
+		"typescript": "^5.8.3",
 		"vitest": "^3.0.5"
 	}
 }

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

@@ -1,10 +0,0 @@
-/**
- * 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.
- * @param {string} vcFileId - The ID of the Verifiable Credential (VC) file in Google Drive.
- * @returns {Promise<{ signedPresentation: object } | null>} - The signed Verifiable Presentation (VP) or null if an error occurs.
- * @throws Will throw an error if the VC is not found, a matching key pair cannot be located, or any part of the signing process fails.
- */
-export declare const createAndSignVerifiablePresentation: (accessTokens: string, vcFileId: string) => Promise<{
-    signedPresentation: object;
-} | null>;

package/dist/utils/presentation.js

@@ -1,45 +0,0 @@
-/**
- * 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.
- * @param {string} vcFileId - The ID of the Verifiable Credential (VC) file in Google Drive.
- * @returns {Promise<{ signedPresentation: object } | null>} - The signed Verifiable Presentation (VP) or null if an error occurs.
- * @throws Will throw an error if the VC is not found, a matching key pair cannot be located, or any part of the signing process fails.
- */
-export const createAndSignVerifiablePresentation = async (accessTokens, vcFileId) => {
-    if (!accessTokens || !vcFileId) {
-        console.error('Invalid input: Access tokens and VC file ID are required.');
-        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: 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);
-        return null;
-    }
-};