@cooperation/vc-storage 1.0.12 → 1.0.14

package/dist/index.js

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

package/dist/models/CredentialEngine.js

@@ -87,17 +87,12 @@ export class CredentialEngine {
         }
     }
     async findKeysAndDIDs() {
-        // find the DID document for the current user
         const keyPairs = (await this.storage.getAllFilesByType('KEYPAIRs'));
-        console.log('🚀 ~ CredentialEngine ~ findDid ~ keyPairs:', keyPairs[0].data);
         const DIDs = (await this.storage.getAllFilesByType('DIDs'));
-        console.log('🚀 ~ CredentialEngine ~ findKeysAndDIDs ~ DIDs:', DIDs);
-        console.log('🚀 ~ CredentialEngine ~ findKeysAndDIDs ~ DIDs:', DIDs[0]);
         if (DIDs.length === 0 || keyPairs.length === 0)
             return null;
         const keyPair = keyPairs[0].data;
         const didDocument = DIDs[0].data.didDocument;
-        console.log('🚀 ~ CredentialEngine ~ findKeysAndDIDs ~ didDocument:', didDocument);
         return {
             didDocument,
             keyPair,

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,22 +94,35 @@ 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,
                 parents: [folderId], // Specify the folder ID
-                mimeType: data.mimeType,
+                mimeType: data.mimeType || 'application/json',
             };
+            // make sure the parentId is not in 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');
+            }
             let uploadUrl = 'https://www.googleapis.com/upload/drive/v3/files?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 })); // Set file data and MIME type
             // Upload file to Google Drive
+            console.log('Uploading file...');
             const file = await this.fetcher({
                 method: 'POST',
                 headers: {},
@@ -109,8 +141,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) {
@@ -277,20 +307,12 @@ export class GoogleDriveStorage {
                 // Fetch all 'VC-timestamp' subfolders under 'VCs'
                 const vcSubfolders = await this.findFolders(targetFolderId);
                 // Retrieve all 'VC.json' files from each 'VC-timestamp' subfolder
-                const fileContents = [];
-                for (const folder of vcSubfolders) {
+                const fileContents = await Promise.all(vcSubfolders.map(async (folder) => {
                     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 Promise.all(files.map(async (file) => {
+                        return await this.retrieve(file.id);
+                    }));
+                }));
                 return fileContents;
             }
             // Step 3: Generic handling for other types
@@ -354,8 +376,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,134 @@
+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) {
+        console.log(`Searching for folder: "${folderName}", Parent ID: ${parentId}`);
+        const folders = await this.storage.findFolders(parentId); // Fetch all child folders of the parent
+        let folder = folders.find((folder) => {
+            console.log('🚀 ~ StorageHandler ~ getOrCreateFolder ~ folder:', folder);
+            return folder.name === folderName;
+        });
+        if (folder && folder.name === 'RESUMES_AUTHOR') {
+            console.log('🚀 ~ StorageHandler ~ getOrCreateFolder ~ folder:', folder);
+        }
+        if (!folder) {
+            console.log(`Folder "${folderName}" not found. Creating under parent: ${parentId}`);
+            folder = await this.storage.createFolder({
+                folderName,
+                parentFolderId: parentId,
+            });
+        }
+        console.log(`Resolved folder: "${folderName}" with ID: ${folder.id}`);
+        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);
+    }
+    signResume({ resume }) {
+        // genetrate unsingned resume
+        // sign resume
+    }
+    async saveResume({ resume, type }) {
+        try {
+            // Get or create the root folder
+            console.log('Checking for root folder...');
+            const rootFolders = await this.storage.findFolders();
+            let rootFolder = rootFolders.find((folder) => folder.name === resumeFolderTypes.root);
+            if (!rootFolder) {
+                console.log('Root folder not found. Creating...');
+                rootFolder = await this.storage.createFolder({ folderName: resumeFolderTypes.root, parentFolderId: 'root' });
+            }
+            console.log('🚀 Root folder resolved:', rootFolder);
+            // Get or create the subfolder
+            const subFolderName = type === 'sign' ? resumeFolderTypes.signed : resumeFolderTypes.nonSigned;
+            const subFolder = await this.getOrCreateFolder(subFolderName, rootFolder.id);
+            console.log(`🚀 Subfolder resolved for type "${type}":`, subFolder);
+            // Save the file in the subfolder
+            console.log(`Saving file in subfolder "${subFolderName}"...`);
+            const savedResume = await this.storage.saveFile({
+                folderId: subFolder.id, // Ensure this points to the subfolder
+                data: resume,
+            });
+            console.log(`🚀 File saved in folder "${subFolderName}" (ID: ${subFolder.id}):`, savedResume);
+            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);
+            console.log(`Files found in "SIGNED_RESUMES":`, files);
+            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();
+            console.log('🚀 ~ Resume ~ getNonSignedResumes ~ rootFolder:', rootFolder);
+            // Find or create the non-signed resumes folder
+            const nonSignedFolder = await this.getOrCreateFolder(resumeFolderTypes.nonSigned, rootFolder.id);
+            console.log('🚀 ~ Resume ~ getNonSignedResumes ~ nonSignedFolder:', nonSignedFolder);
+            // Retrieve all files from the non-signed folder
+            const files = await this.storage.findFilesUnderFolder(nonSignedFolder.id);
+            console.log(`Files found in "NON_SIGNED_RESUMES":`, files);
+            return files;
+        }
+        catch (error) {
+            throw new Error('Error while fetching non-signed resumes: ' + error.message);
+        }
+    }
+    async findRootFolder() {
+        console.log('Searching for the root folder...');
+        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.`);
+        }
+        console.log('Root folder found:', rootFolder);
+        return rootFolder;
+    }
+    generarteUnsignedResume() { }
+    isResumeFolderExist() { }
+}
+export default Resume;

package/dist/types/index.d.ts

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

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>;
     /**
@@ -64,7 +73,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,32 @@
+import { GoogleDriveStorage } from './GoogleDriveStorage';
+export declare const resumeFolderTypes: {
+    root: string;
+    nonSigned: string;
+    signed: string;
+};
+export declare class StorageHandler {
+    protected storage: GoogleDriveStorage;
+    constructor(storage: GoogleDriveStorage);
+    protected getOrCreateFolder(folderName: string, parentId: string): Promise<any>;
+    protected findFilesInFolder(folderName: string): Promise<any[]>;
+}
+export declare class Resume extends StorageHandler {
+    constructor(storage: GoogleDriveStorage);
+    signResume({ resume }: {
+        resume: any;
+    }): void;
+    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 generarteUnsignedResume;
+    private isResumeFolderExist;
+}
+export default Resume;

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

@@ -34,26 +34,22 @@ export async function saveToGoogleDrive({ storage, data, type }) {
         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 });
+            const vcFolder = await storage.createFolder({ folderName: `${fileData.fileName}-${Date.now()}`, parentFolderId: typeFolderId });
+            const file = await storage.saveFile({ data: fileData, folderId: vcFolder.id });
             console.log(`File uploaded: ${file?.id} under ${fileData.fileName} folder in VCs folder`);
             return file;
         }
@@ -78,22 +74,17 @@ 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');
+            console.log('Credentials folder not found. Creating...');
+            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,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.12",
+	"version": "1.0.14",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -20,7 +20,9 @@
 		"@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",
 		"uuid": "^10.0.0"
 	},