@cooperation/vc-storage 1.0.13 → 1.0.15

package/dist/index.js

@@ -2,3 +2,5 @@ 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';

package/dist/models/GoogleDriveStorage.js

@@ -51,6 +51,22 @@ export class GoogleDriveStorage {
             throw error;
         }
     }
+    async getFileContent(fileId) {
+        const url = `https://www.googleapis.com/drive/v3/files/${fileId}?alt=media`;
+        try {
+            const response = await this.fetcher({
+                method: 'GET',
+                headers: {}, // Add additional headers if required
+                url,
+            });
+            console.log(`Content fetched for file ID: ${fileId}`);
+            return response; // This could be text, JSON, or binary, depending on the file type
+        }
+        catch (error) {
+            console.error(`Error fetching content for file ID: ${fileId}:`, error.message);
+            throw new Error(`Failed to fetch content for file ID: ${fileId}`);
+        }
+    }
     async searchFiles(query) {
         const result = await this.fetcher({
             method: 'GET',
@@ -63,11 +79,14 @@ export class GoogleDriveStorage {
         }
         return result.files;
     }
-    async createFolder(folderName, parentFolderId) {
+    async createFolder({ folderName, parentFolderId }) {
+        if (!parentFolderId) {
+            throw new Error(`Parent folder ID must be provided when creating folder "${folderName}".`);
+        }
         const metadata = {
             name: folderName,
             mimeType: 'application/vnd.google-apps.folder',
-            parents: parentFolderId ? [parentFolderId] : [],
+            parents: [parentFolderId], // Explicitly associate with the parent folder
         };
         const folder = await this.fetcher({
             method: 'POST',
@@ -75,27 +94,44 @@ export class GoogleDriveStorage {
             body: JSON.stringify(metadata),
             url: 'https://www.googleapis.com/drive/v3/files',
         });
-        console.log('Folder ID:', folder.id);
-        return folder.id;
+        console.log(`Folder created: "${folderName}" with ID: ${folder.id}, Parent: ${parentFolderId}`);
+        return folder;
     }
     async saveFile({ data, folderId }) {
         try {
+            if (!folderId) {
+                throw new Error('Folder ID is required to save a file.');
+            }
             // Define file metadata, ensure correct folder is assigned
             const fileMetadata = {
-                name: data.fileName,
+                name: data.fileName || 'resume.json', // Use the provided fileName or default to 'resume.json'
                 parents: [folderId], // Specify the folder ID
-                mimeType: data.mimeType,
+                mimeType: 'application/json', // Ensure the MIME type is set to JSON
             };
-            let uploadUrl = 'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart';
+            // Check if the parent folder is in the trash
+            const folder = await this.fetcher({
+                method: 'GET',
+                headers: {},
+                url: `https://www.googleapis.com/drive/v3/files/${folderId}?fields=trashed`,
+            });
+            if (folder.trashed) {
+                throw new Error('Parent folder is in trash');
+            }
+            // Prepare the file content as a JSON string
+            const fileContent = JSON.stringify(data);
+            // Create a Blob from the JSON string
+            const fileBlob = new Blob([fileContent], { type: 'application/json' });
+            // Create FormData and append the metadata and file content
             const formData = new FormData();
             formData.append('metadata', new Blob([JSON.stringify(fileMetadata)], { type: 'application/json' }));
-            formData.append('file', new Blob([data.body], { type: fileMetadata.mimeType })); // Set file data and MIME type
+            formData.append('file', fileBlob);
             // Upload file to Google Drive
+            console.log('Uploading file...');
             const file = await this.fetcher({
                 method: 'POST',
                 headers: {},
                 body: formData,
-                url: `${uploadUrl}&fields=id,parents`, // Request the file ID and parent folder IDs
+                url: `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,parents`,
             });
             // Set the file permission to "Anyone with the link" can view
             const permissionUrl = `https://www.googleapis.com/drive/v3/files/${file.id}/permissions`;
@@ -109,8 +145,6 @@ export class GoogleDriveStorage {
                 headers: {},
                 body: JSON.stringify(permissionData),
             });
-            console.log('Permission set to public for file:', file.id);
-            console.log('Parent folder IDs:', file.parents);
             return file;
         }
         catch (error) {
@@ -197,58 +231,6 @@ export class GoogleDriveStorage {
         const folders = await this.searchFiles(query);
         return folders.filter((file) => file.mimeType === 'application/vnd.google-apps.folder');
     };
-    /**
-     * Get the last file from folder by folderId
-     * @param folderId
-     * @returns last file content from folder by folderId
-     */
-    findLastFile = async (folderId) => {
-        try {
-            const files = await this.searchFiles(`'${folderId}' in parents`);
-            const fileContents = await Promise.all(files
-                .filter((file) => file.mimeType !== 'application/vnd.google-apps.folder')
-                .map(async (file) => {
-                const content = await this.fetcher({
-                    method: 'GET',
-                    headers: {},
-                    url: `https://www.googleapis.com/drive/v3/files/${file.id}?alt=media`,
-                });
-                return {
-                    ...file,
-                    content,
-                };
-            }));
-            // Find the latest file based on the timestamp in the file name
-            const latestFile = fileContents.reduce((latest, current) => {
-                // Check if the file name has the expected structure
-                const nameParts = current.name.split('_');
-                let currentTimestampStr;
-                if (nameParts.length === 3) {
-                    // Structure with UUID: `${uuid}_${type}_${timestamp}.json`
-                    currentTimestampStr = nameParts[2];
-                }
-                else if (nameParts.length === 2) {
-                    // Structure without UUID: `${type}_${timestamp}.json`
-                    currentTimestampStr = nameParts[1];
-                }
-                else {
-                    // Log warning and skip this file if the structure is not as expected
-                    console.warn(`Unexpected file name format: ${current.name}`);
-                    return latest;
-                }
-                // Parse the timestamp from the file name
-                const latestTimestamp = latest ? parseInt(latest.name.split('_').pop().split('.')[0], 10) : 0;
-                const currentTimestamp = parseInt(currentTimestampStr.split('.')[0], 10);
-                return currentTimestamp > latestTimestamp ? current : latest;
-            }, null);
-            // Return the content of the latest file
-            return latestFile ? latestFile.content : null;
-        }
-        catch (error) {
-            console.error('Error finding last file:', error);
-            return null;
-        }
-    };
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type
@@ -283,18 +265,6 @@ export class GoogleDriveStorage {
                         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
@@ -358,8 +328,24 @@ export class GoogleDriveStorage {
         if (!folderId)
             throw new Error('Folder ID is required');
         console.log('🚀 ~ GoogleDriveStorage ~ findFilesUnderFolder ~ folderId', folderId);
+        // Fetch files under the folder
         const files = await this.searchFiles(`'${folderId}' in parents`);
-        return files;
+        if (files.length === 0) {
+            console.log('No files found in the folder.');
+            return [];
+        }
+        // Fetch content for each file
+        const filesWithContent = await Promise.all(files.map(async (file) => {
+            try {
+                const content = await this.getFileContent(file.id);
+                return { ...file, content }; // Merge file metadata with its content
+            }
+            catch (error) {
+                console.error(`Error fetching content for file "${file.name}" (ID: ${file.id}):`, error);
+                return { ...file, content: null }; // Handle errors gracefully
+            }
+        }));
+        return filesWithContent;
     }
     async updateFileData(fileId, data) {
         const fileMetadata = {

package/dist/models/Resume.js

@@ -0,0 +1,110 @@
+export const resumeFolderTypes = {
+    root: 'RESUMES_AUTHOR',
+    nonSigned: 'NON_SIGNED_RESUMES',
+    signed: 'SIGNED_RESUMES',
+};
+export class StorageHandler {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async getOrCreateFolder(folderName, parentId) {
+        const folders = await this.storage.findFolders(parentId); // Fetch all child folders of the parent
+        let folder = folders.find((folder) => {
+            return folder.name === folderName;
+        });
+        if (!folder) {
+            folder = await this.storage.createFolder({
+                folderName,
+                parentFolderId: parentId,
+            });
+        }
+        return folder;
+    }
+    async findFilesInFolder(folderName) {
+        const folders = await this.storage.findFolders();
+        const folder = folders.find((folder) => folder.name === folderName);
+        if (!folder) {
+            throw new Error(`${folderName} folder not found`);
+        }
+        return this.storage.findFilesUnderFolder(folder.id);
+    }
+}
+export class Resume extends StorageHandler {
+    constructor(storage) {
+        super(storage);
+    }
+    async saveResume({ resume, type }) {
+        try {
+            // Get or create the root folder
+            const rootFolders = await this.storage.findFolders();
+            let rootFolder = rootFolders.find((folder) => folder.name === resumeFolderTypes.root);
+            if (!rootFolder) {
+                rootFolder = await this.storage.createFolder({ folderName: resumeFolderTypes.root, parentFolderId: 'root' });
+            }
+            // Get or create the subfolder
+            const subFolderName = type === 'sign' ? resumeFolderTypes.signed : resumeFolderTypes.nonSigned;
+            const subFolder = await this.getOrCreateFolder(subFolderName, rootFolder.id);
+            // Save the file in the subfolder
+            const savedResume = await this.storage.saveFile({
+                folderId: subFolder.id, // Ensure this points to the subfolder
+                data: resume,
+            });
+            return savedResume;
+        }
+        catch (error) {
+            throw new Error(`Error while saving ${type} resume: ${error.message}`);
+        }
+    }
+    async find() {
+        try {
+            const signedResumes = await this.getSignedResumes();
+            const nonSignedResumes = await this.getNonSignedResumes();
+            return {
+                signed: signedResumes,
+                nonSigned: nonSignedResumes,
+            };
+        }
+        catch (error) {
+            throw new Error('Error while fetching resume: ' + error.message);
+        }
+    }
+    async getSignedResumes() {
+        try {
+            // Find the root folder first
+            const rootFolder = await this.findRootFolder();
+            // 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);
+            return files;
+        }
+        catch (error) {
+            throw new Error('Error while fetching signed resumes: ' + error.message);
+        }
+    }
+    async getNonSignedResumes() {
+        try {
+            // Find the root folder first
+            const rootFolder = await this.findRootFolder();
+            // 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);
+            return files;
+        }
+        catch (error) {
+            throw new Error('Error while fetching non-signed resumes: ' + error.message);
+        }
+    }
+    async findRootFolder() {
+        const rootFolders = await this.storage.findFolders(); // Fetch all root-level folders
+        const rootFolder = rootFolders.find((folder) => folder.name === resumeFolderTypes.root);
+        if (!rootFolder) {
+            throw new Error(`Root folder "${resumeFolderTypes.root}" not found in the root directory.`);
+        }
+        return rootFolder;
+    }
+    isResumeFolderExist() { }
+}
+export default Resume;

package/dist/models/ResumeVC.js

@@ -0,0 +1,84 @@
+import { Ed25519Signature2020 } from '@digitalbazaar/ed25519-signature-2020';
+import { customDocumentLoader } from '../utils/digitalbazaar.js';
+import { v4 as uuidv4 } from 'uuid';
+import * as dbVc from '@digitalbazaar/vc';
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+import { generateDIDSchema } from '../utils/credential.js';
+import { inlineResumeContext } from '../utils/context.js';
+export class ResumeVC {
+    async sign({ formData, issuerDid, keyPair }) {
+        const unsignedCredential = this.generateUnsignedCredential({ formData, issuerDid });
+        const suite = new Ed25519Signature2020({
+            key: new Ed25519VerificationKey2020(keyPair), // Ensure proper initialization
+            verificationMethod: keyPair.id,
+        });
+        try {
+            const signedVC = await dbVc.issue({
+                credential: unsignedCredential,
+                suite,
+                documentLoader: customDocumentLoader,
+            });
+            console.log('Signed VC:', signedVC);
+        }
+        catch (error) {
+            console.error('Error signing VC:', error.message);
+            if (error.details) {
+                console.error('Error details:', JSON.stringify(error.details, null, 2));
+            }
+            throw error;
+        }
+        return unsignedCredential;
+    }
+    generateUnsignedCredential({ formData, issuerDid }) {
+        const unsignedCredential = {
+            '@context': [
+                'https://www.w3.org/2018/credentials/v1', // Standard VC context
+                inlineResumeContext['@context'], // Inline context
+            ],
+            id: `urn:uuid:${uuidv4()}`, // Generate a dynamic UUID
+            type: ['VerifiableCredential'],
+            issuer: issuerDid,
+            issuanceDate: new Date().toISOString(),
+            credentialSubject: {
+                type: 'Resume',
+                person: {
+                    name: {
+                        formattedName: formData.formattedName,
+                    },
+                    primaryLanguage: formData.primaryLanguage,
+                },
+                narrative: formData.narrative,
+                employmentHistory: formData.employmentHistory,
+                skills: formData.skills,
+                educationAndLearning: formData.educationAndLearning,
+            },
+        };
+        return unsignedCredential;
+    }
+    generateKeyPair = async (address) => {
+        // Generate the key pair using the library's method
+        const keyPair = await Ed25519VerificationKey2020.generate();
+        // Configure key pair attributes
+        const a = address || keyPair.publicKeyMultibase;
+        keyPair.controller = `did:key:${a}`;
+        keyPair.id = `${keyPair.controller}#${a}`;
+        keyPair.revoked = false;
+        // The `signer` is already provided by the `Ed25519VerificationKey2020` instance
+        return keyPair;
+    };
+    /**
+     * Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
+     * @returns {Promise<{didDocument: object, keyPair: object}>} The created DID document and key pair.
+     * @throws Will throw an error if DID creation fails.
+     */
+    async createDID({ keyPair }) {
+        try {
+            const didDocument = await generateDIDSchema(keyPair);
+            return didDocument;
+        }
+        catch (error) {
+            console.error('Error creating DID:', error);
+            throw error;
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -2,3 +2,5 @@ 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';

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

@@ -1,4 +1,4 @@
-import { DataToSaveI, FilesType } from '../../types';
+import { DataToSaveI } from '../../types';
 interface FileContent {
     name: string;
     content: any;
@@ -23,10 +23,19 @@ export declare class GoogleDriveStorage {
     private accessToken;
     constructor(accessToken: string);
     private fetcher;
+    private getFileContent;
     private searchFiles;
-    createFolder(folderName: string, parentFolderId?: string): Promise<string>;
+    createFolder({ folderName, parentFolderId }: {
+        folderName: string;
+        parentFolderId: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        mimeType: string;
+        parents: string[];
+    }>;
     saveFile({ data, folderId }: {
-        data: DataToSaveI;
+        data: any;
         folderId: string;
     }): Promise<any>;
     /**
@@ -45,12 +54,6 @@ export declare class GoogleDriveStorage {
      * @returns
      */
     findFolders: (folderId?: string) => Promise<any[]>;
-    /**
-     * Get the last file from folder by folderId
-     * @param folderId
-     * @returns last file content from folder by folderId
-     */
-    findLastFile: (folderId: string) => Promise<any>;
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type
@@ -64,7 +67,7 @@ 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>;
+    findFileByName(name: string): Promise<any>;
     findFilesUnderFolder(folderId: string): Promise<any[]>;
     updateFileData(fileId: string, data: DataToSaveI): Promise<any>;
     getFileParents(fileId: string): Promise<any>;

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

@@ -0,0 +1,28 @@
+import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+export declare const resumeFolderTypes: {
+    root: string;
+    nonSigned: string;
+    signed: string;
+};
+export declare class StorageHandler {
+    protected storage: GoogleDriveStorage;
+    constructor(storage: GoogleDriveStorage);
+    getOrCreateFolder(folderName: string, parentId: string): Promise<any>;
+    protected findFilesInFolder(folderName: string): Promise<any[]>;
+}
+export declare class Resume extends StorageHandler {
+    constructor(storage: GoogleDriveStorage);
+    saveResume({ resume, type }: {
+        resume: any;
+        type: 'sign' | 'unsigned';
+    }): Promise<any>;
+    find(): Promise<{
+        signed: any[];
+        nonSigned: any[];
+    }>;
+    getSignedResumes(): Promise<any[]>;
+    getNonSignedResumes(): Promise<any[]>;
+    private findRootFolder;
+    private isResumeFolderExist;
+}
+export default Resume;

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

@@ -0,0 +1,17 @@
+export declare class ResumeVC {
+    sign({ formData, issuerDid, keyPair }: {
+        formData: any;
+        issuerDid: string;
+        keyPair: any;
+    }): Promise<any>;
+    private generateUnsignedCredential;
+    generateKeyPair: (address?: string) => Promise<any>;
+    /**
+     * Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
+     * @returns {Promise<{didDocument: object, keyPair: object}>} The created DID document and key pair.
+     * @throws Will throw an error if DID creation fails.
+     */
+    createDID({ keyPair }: {
+        keyPair: any;
+    }): Promise<import("../../types/credential.js").DidDocument>;
+}

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

@@ -1,3 +1,33 @@
+export declare const inlineResumeContext: {
+    '@context': {
+        '@vocab': string;
+        name: string;
+        formattedName: string;
+        primaryLanguage: string;
+        narrative: string;
+        text: string;
+        employmentHistory: {
+            '@id': string;
+            '@container': string;
+        };
+        company: string;
+        position: string;
+        duration: string;
+        skills: {
+            '@id': string;
+            '@container': string;
+        };
+        educationAndLearning: string;
+        degree: string;
+        institution: string;
+        year: string;
+        issuanceDate: string;
+        issuer: string;
+        credentialSubject: string;
+        person: string;
+        Resume: string;
+    };
+};
 declare let localOBContext: {
     '@context': {
         '@protected': boolean;

package/dist/utils/context.js

@@ -1,4 +1,33 @@
-// Load the local context files
+export const inlineResumeContext = {
+    '@context': {
+        '@vocab': 'https://schema.hropenstandards.org/4.4/',
+        name: 'https://schema.org/name',
+        formattedName: 'https://schema.org/formattedName',
+        primaryLanguage: 'https://schema.org/primaryLanguage',
+        narrative: 'https://schema.org/narrative',
+        text: 'https://schema.org/text',
+        employmentHistory: {
+            '@id': 'https://schema.org/employmentHistory',
+            '@container': '@list', // Specify list container
+        },
+        company: 'https://schema.org/company',
+        position: 'https://schema.org/jobTitle',
+        duration: 'https://schema.org/temporalCoverage',
+        skills: {
+            '@id': 'https://schema.org/skills',
+            '@container': '@list', // Specify list container
+        },
+        educationAndLearning: 'https://schema.org/educationAndLearning',
+        degree: 'https://schema.org/degree',
+        institution: 'https://schema.org/institution',
+        year: 'https://schema.org/year',
+        issuanceDate: 'https://schema.org/issuanceDate',
+        issuer: 'https://schema.org/issuer',
+        credentialSubject: 'https://schema.org/credentialSubject',
+        person: 'https://schema.org/Person', // Added person
+        Resume: 'https://schema.hropenstandards.org/4.4#Resume', // Map Resume to an absolute IRI
+    },
+};
 let localOBContext = {
     '@context': {
         '@protected': true,

package/dist/utils/credential.js

@@ -1,6 +1,6 @@
 import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
-import crypto from 'crypto';
 import { v4 as uuidv4 } from 'uuid';
+import CryptoJS from 'crypto-js';
 /**
  * Utility function to generate a hashed ID for a credential.
  * Excludes the `id` field when hashing.
@@ -11,7 +11,7 @@ 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');
+    return CryptoJS.SHA256(serialized).toString(CryptoJS.enc.Hex);
 }
 /**
  * Create a DID document using the provided key pair.

package/dist/utils/google.js

@@ -29,37 +29,31 @@ export async function saveToGoogleDrive({ storage, data, type }) {
         };
         // 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');
-        }
-        else {
-            credentialsFolderId = credentialsFolder.id;
+            credentialsFolder = await storage.createFolder({ folderName: 'Credentials', parentFolderId: 'root' });
         }
+        credentialsFolderId = credentialsFolder.id;
         // Get subfolders within the "Credentials" folder
         const subfolders = await storage.findFolders(credentialsFolderId);
         // 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);
-        }
-        else {
-            typeFolderId = typeFolder.id;
+            typeFolder = await storage.createFolder({ folderName: `${type}s`, parentFolderId: credentialsFolderId });
         }
+        typeFolderId = typeFolder.id;
         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`);
+            const vcFolder = await storage.createFolder({ folderName: `${fileData.fileName}-${Date.now()}`, parentFolderId: typeFolderId });
+            const file = await storage.saveFile({ data: fileData, folderId: vcFolder.id });
             return file;
         }
         // Save the file in the specific subfolder
         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`);
+        console.log('🚀 ~ file:', file);
         return file;
     }
     catch (error) {
@@ -78,22 +72,16 @@ export async function uploadImageToGoogleDrive(storage, imageFile) {
     try {
         const rootFolders = await storage.findFolders();
         let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
-        let credentialsFolderId;
         if (!credentialsFolder) {
-            credentialsFolderId = await storage.createFolder('Credentials');
+            credentialsFolder = await storage.createFolder({ folderName: 'Credentials', parentFolderId: 'root' });
         }
-        else {
-            credentialsFolderId = credentialsFolder.id;
-        }
-        const subfolders = await storage.findFolders(credentialsFolderId);
+        const credentialsFolderId = credentialsFolder.id;
+        const subfolders = await storage.findFolders(credentialsFolder.id);
         let mediasFolder = subfolders.find((f) => f.name === 'MEDIAs');
-        let mediasFolderId;
         if (!mediasFolder) {
-            mediasFolderId = await storage.createFolder('MEDIAs', credentialsFolderId);
-        }
-        else {
-            mediasFolderId = mediasFolder.id;
+            mediasFolder = await storage.createFolder({ folderName: 'MEDIAs', parentFolderId: credentialsFolderId });
         }
+        const mediasFolderId = mediasFolder.id;
         // Prepare the image file data
         const imageData = {
             fileName: imageFile.name,
@@ -105,7 +93,7 @@ export async function uploadImageToGoogleDrive(storage, imageFile) {
             data: imageData,
             folderId: mediasFolderId,
         });
-        console.log(`Image uploaded: ${uploadedImage?.id} to MEDIAs folder in Credentials`);
+        console.log('🚀 ~ uploadedImage:', uploadedImage);
         return uploadedImage;
     }
     catch (error) {

package/package.json

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