@cooperation/vc-storage 1.0.1 → 1.0.5

package/dist/models/GoogleDriveStorage.js

@@ -1,8 +1,25 @@
+import { generateViewLink } from '../utils/google.js';
+/**
+ * @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 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 delete - Delete a file from Google Drive
+ */
 export class GoogleDriveStorage {
     accessToken;
     constructor(accessToken) {
         this.accessToken = accessToken;
     }
+    // Method to fetch data from Google Drive API
     async fetcher({ method, headers, body, url }) {
         try {
             const res = await fetch(url, {
@@ -13,18 +30,20 @@ export class GoogleDriveStorage {
                 }),
                 body,
             });
+            // Check for errors in the response
             const data = await res.json();
             if (!res.ok) {
-                throw new Error(data.error.message);
+                console.error('Error Response:', JSON.stringify(data));
+                throw new Error(data.error.message || 'Unknown error');
             }
             return data;
         }
         catch (error) {
-            console.error('Error fetching data:', error);
+            console.error('Error fetching data:', error.message);
             throw error;
         }
     }
-    // New method to encapsulate search logic
+    // Method to search for files in Google Drive by query
     async searchFiles(query) {
         const result = await this.fetcher({
             method: 'GET',
@@ -50,28 +69,103 @@ export class GoogleDriveStorage {
     }
     async save(data, folderId) {
         try {
+            // Define file metadata, ensure correct folder is assigned
             const fileMetadata = {
                 name: data.fileName,
-                mimeType: data.mimeType,
-                parents: [folderId],
+                parents: [folderId], // Specify the folder ID
+                mimeType: 'application/json', // Use provided MIME type or default to JSON
             };
+            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', data.body);
+            formData.append('file', new Blob([data.body], { type: fileMetadata.mimeType })); // Set file data and MIME type
             const file = await this.fetcher({
                 method: 'POST',
                 headers: {},
                 body: formData,
-                url: 'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart',
+                url: uploadUrl,
             });
-            console.log('File uploaded:', file.id);
+            console.log('File uploaded successfully:', file.id);
             return file;
         }
         catch (error) {
-            console.error('Error uploading file:', error);
+            console.error('Error uploading file:', error.message);
             return null;
         }
     }
+    /**
+     * Add comment to VC
+     * @param fileId - th id of VC file
+     * @returns
+     */
+    async addCommentToFile(vcFileId, recommendationFileId) {
+        if (!recommendationFileId || !vcFileId || !this.accessToken) {
+            throw new Error('Missing required parameters: fileId, commentText, or accessToken');
+        }
+        const url = `https://www.googleapis.com/drive/v3/files/${vcFileId}/comments?fields=id,content,createdTime`;
+        const body = {
+            content: generateViewLink(recommendationFileId),
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorDetails = await response.json();
+                throw new Error(`Failed to add comment: ${JSON.stringify(errorDetails)}`);
+            }
+            const result = await response.json();
+            console.log('Comment added successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Error adding comment to file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Add commenter role to a file
+     * @param fileId
+     * @returns
+     */
+    async addCommenterRoleToFile(fileId) {
+        const url = `https://www.googleapis.com/drive/v3/files/${fileId}/permissions`;
+        const body = {
+            role: 'commenter',
+            type: 'anyone',
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const errorDetails = await response.json();
+                throw new Error(`Failed to add permission: ${JSON.stringify(errorDetails)}`);
+            }
+            const result = await response.json();
+            console.log('Permission added successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Error adding permission:', error.message);
+            throw error;
+        }
+    }
+    /**
+     * Get file from google drive by id
+     * @param id
+     * @returns file content
+     */
     async retrieve(id) {
         try {
             const file = await this.fetcher({
@@ -79,7 +173,6 @@ export class GoogleDriveStorage {
                 headers: {},
                 url: `https://www.googleapis.com/drive/v3/files/${id}?alt=media`,
             });
-            console.log('File retrieved:', file);
             return file;
         }
         catch (error) {
@@ -87,13 +180,23 @@ export class GoogleDriveStorage {
             return null;
         }
     }
-    findFolders = async (id) => {
-        const query = id
-            ? `'${id}' in parents and mimeType='application/vnd.google-apps.folder'`
+    /**
+     * Get folder by folderId, if folderId == null you will have them all
+     * @param id [Optional]
+     * @returns
+     */
+    findFolders = async (folderId) => {
+        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);
         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`);
@@ -110,11 +213,30 @@ export class GoogleDriveStorage {
                     content,
                 };
             }));
+            // Find the latest file based on the timestamp in the file name
             const latestFile = fileContents.reduce((latest, current) => {
-                const latestTimestamp = latest ? parseInt(latest.name.split('-')[1].split('.')[0], 10) : 0;
-                const currentTimestamp = parseInt(current.name.split('-')[1].split('.')[0], 10);
+                // 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) {
@@ -122,75 +244,75 @@ export class GoogleDriveStorage {
             return null;
         }
     };
-    async getAllClaims() {
-        const rootFolders = await this.findFolders();
-        const credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
-        if (!credentialsFolder)
-            return [];
-        const credentialsFolderId = credentialsFolder.id;
-        const subfolders = await this.findFolders(credentialsFolderId);
-        const signedVCFolder = subfolders.find((f) => f.name === 'VCs');
-        if (!signedVCFolder)
-            return [];
-        const claims = await this.fetcher({
-            method: 'GET',
-            headers: {},
-            url: `https://www.googleapis.com/drive/v3/files?q='${signedVCFolder.id}' in parents and trashed=false&fields=files(id,name,mimeType,parents)`,
-        });
-        return claims;
-    }
-    async getAllSessions() {
+    async getFileComments(fileId) {
         try {
-            // Find all root folders
-            const rootFolders = await this.fetcher({
+            // Fetch comments on the file using Google Drive API
+            const commentsResponse = await this.fetcher({
                 method: 'GET',
                 headers: {},
-                url: `https://www.googleapis.com/drive/v3/files?q='root' in parents and mimeType='application/vnd.google-apps.folder'&trashed=false&fields=files(id,name)`,
+                url: `https://www.googleapis.com/drive/v3/files/${fileId}/comments?fields=comments(content,author/displayName,createdTime)`,
             });
-            console.log('🚀 ~ GoogleDriveStorage ~ getAllSessions ~ rootFolders:', rootFolders);
-            // Find the "Credentials" folder
-            const credentialsFolder = rootFolders.files.find((f) => f.name === 'Credentials');
-            if (!credentialsFolder) {
-                return []; // Return an empty array if "Credentials" folder is not found
-            }
+            // Return the comments data if available
+            return commentsResponse.comments || []; // Return an empty array if no comments
+        }
+        catch (error) {
+            console.error(`Failed to fetch comments for file ID: ${fileId}`, error);
+            return []; // Handle errors by returning an empty array or some error indication
+        }
+    }
+    /**
+     * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
+     * @param type
+     * @returns
+     */
+    async getAllFilesByType(type) {
+        try {
+            // Step 1: Find all root folders
+            const rootFolders = await this.findFolders();
+            const credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
+            if (!credentialsFolder)
+                return [];
             const credentialsFolderId = credentialsFolder.id;
-            // Find subfolders within the "Credentials" folder
-            const subfolders = await this.fetcher({
-                method: 'GET',
-                headers: {},
-                url: `https://www.googleapis.com/drive/v3/files?q='${credentialsFolderId}' in parents and mimeType='application/vnd.google-apps.folder'&trashed=false&fields=files(id,name)`,
-            });
-            const sessionsFolder = subfolders.files.find((f) => f.name === 'SESSIONs');
-            if (!sessionsFolder) {
-                return []; // Return an empty array if "SESSIONs" folder is not found
-            }
-            // Fetch all session files inside the "SESSIONs" folder
-            const sessions = await this.fetcher({
+            // Step 2: Find the subfolder corresponding to the specified type
+            const subfolders = await this.findFolders(credentialsFolderId);
+            const targetFolder = subfolders.find((f) => f.name === type);
+            if (!targetFolder)
+                return [];
+            // Step 3: Fetch all files in the specified folder
+            const filesResponse = await this.fetcher({
                 method: 'GET',
                 headers: {},
-                url: `https://www.googleapis.com/drive/v3/files?q='${sessionsFolder.id}' in parents and trashed=false&fields=files(id,name,mimeType,parents)`,
+                url: `https://www.googleapis.com/drive/v3/files?q='${targetFolder.id}' in parents and trashed=false&fields=files(id,name,mimeType,parents)`,
             });
-            const sessionFiles = sessions.files;
-            // Fetch the content of each session file
-            const sessionContents = await Promise.all(sessionFiles.map(async (file) => {
+            const files = filesResponse.files;
+            // Step 4: Fetch the content and comments of each file
+            const fileContents = await Promise.all(files.map(async (file) => {
                 // Fetch file content
                 const content = await this.fetcher({
                     method: 'GET',
                     headers: {},
                     url: `https://www.googleapis.com/drive/v3/files/${file.id}?alt=media`,
                 });
+                // Fetch file comments (if applicable)
+                const comments = await this.getFileComments(file.id);
                 return {
+                    name: file.name,
                     content,
+                    comments: comments.map((comment) => comment.content),
                 };
             }));
-            console.log('🚀 ~ GoogleDriveStorage ~ getAllSessions ~ sessionContents:', sessionContents);
-            return sessionContents; // Return the list of files with their content
+            return fileContents; // Return the list of files with their content and comments
         }
         catch (error) {
-            console.error('Error getting session contents:', error);
+            console.error(`Error getting files of type ${type}:`, error);
             return []; // Return an empty array on error
         }
     }
+    /**
+     * Delete file by id
+     * @param id
+     * @returns
+     */
     async delete(id) {
         try {
             const response = await this.fetcher({

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './models/GoogleDriveStorage.js';
 export * from './models/CredentialEngine.js';
-export { saveToGoogleDrive } from './utils/saveToGoogle.js';
+export * from './utils/google.js';
+export * from './utils/presentation.js';

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

@@ -1,12 +1,24 @@
-import { KeyPair, FormDataI, Credential, DidDocument } from '../../types/Credential.js';
-export declare const customDocumentLoader: (url: string) => Promise<any>;
+import { DidDocument, KeyPair, VerifiableCredential } from '../../types/credential.js';
+/**
+ * Class representing the Credential Engine.
+ * @class CredentialEngine
+ * @param {string} accessToken - The access token for the user.
+ * @classdesc Credential Engine class to create DIDs and VCs.
+ * @method createDID - Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
+ * @method createWalletDID - Create a new DID with user metamask address as controller.
+ * @method signVC - Sign a Verifiable Credential (VC).
+ * @method verifyCredential - Verify a Verifiable Credential (VC).
+ * @method createPresentation - Create a Verifiable Presentation (VP).
+ * @method signPresentation - Sign a Verifiable Presentation (VP).
+ */
 export declare class CredentialEngine {
-    /**
-     * Create a DID document using the provided key pair.
-     * @param {object} keyPair - The key pair used to create the DID document.
-     * @returns {Promise<object>} The created DID document.
-     */
-    private generateDIDSchema;
+    private uuid;
+    private storage;
+    private keyPair;
+    constructor(accessToken: string);
+    private getKeyPair;
+    private generateKeyPair;
+    private verifyCreds;
     /**
      * Create a new DID with Digital Bazaar's Ed25519VerificationKey2020 key pair.
      * @returns {Promise<{didDocument: object, keyPair: object}>} The created DID document and key pair.
@@ -26,20 +38,32 @@ export declare class CredentialEngine {
         didDocument: DidDocument;
         keyPair: KeyPair;
     }>;
-    /**
-     * Create an unsigned Verifiable Credential (VC)
-     * @param {object} formData - The form data to include in the VC.
-     * @param {string} issuerDid - The DID of the issuer.
-     * @returns {Promise<object>} The created unsigned VC.
-     * @throws Will throw an error if unsigned VC creation fails.
-     */
-    createUnsignedVC(formData: FormDataI, issuerDid: string): Promise<Credential>;
     /**
      * Sign a Verifiable Credential (VC)
-     * @param {object} credential - The credential to sign.
-     * @param {object} keyPair - The key pair to use for signing.
-     * @returns {Promise<object>} The signed VC.
+     * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
+     * @param {string} issuerId - The ID of the issuer [currently we put it as the did id]
+     * @param {KeyPair} keyPair - The key pair to use for signing.
+     * @returns {Promise<Credential>} The signed VC.
      * @throws Will throw an error if VC signing fails.
      */
-    signVC(credential: Credential, keyPair: KeyPair): Promise<Credential>;
+    signVC(formData: any, type: 'VC' | 'RECOMMENDATION', keyPair: KeyPair, issuerId: string): Promise<any>;
+    /**
+     * Verify a Verifiable Credential (VC)
+     * @param {object} credential - The Verifiable Credential to verify.
+     * @returns {Promise<boolean>} The verification result.
+     * @throws Will throw an error if VC verification fails.
+     */
+    verifyCredential(credential: VerifiableCredential): Promise<boolean>;
+    /**
+     * Create a Verifiable Presentation (VP)
+     * @param verifiableCredential
+     * @returns
+     */
+    createPresentation(verifiableCredential: VerifiableCredential[]): Promise<any>;
+    /**
+     * Sign a Verifiable Presentation (VP)
+     * @param presentation
+     * @returns
+     */
+    signPresentation(presentation: any): Promise<any>;
 }

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

@@ -1,4 +1,24 @@
 import { DataToSaveI } from '../../types';
+interface FileContent {
+    name: string;
+    content: any;
+    comments: string[];
+}
+/**
+ * @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 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 delete - Delete a file from Google Drive
+ */
 export declare class GoogleDriveStorage {
     private accessToken;
     constructor(accessToken: string);
@@ -8,10 +28,48 @@ export declare class GoogleDriveStorage {
     save(data: DataToSaveI, folderId: string): Promise<{
         id: string;
     } | null>;
+    /**
+     * Add comment to VC
+     * @param fileId - th id of VC file
+     * @returns
+     */
+    addCommentToFile(vcFileId: string, recommendationFileId: string): Promise<any>;
+    /**
+     * Add commenter role to a file
+     * @param fileId
+     * @returns
+     */
+    addCommenterRoleToFile(fileId: string): Promise<any>;
+    /**
+     * Get file from google drive by id
+     * @param id
+     * @returns file content
+     */
     retrieve(id: string): Promise<any>;
-    findFolders: (id?: string) => Promise<any[]>;
+    /**
+     * Get folder by folderId, if folderId == null you will have them all
+     * @param id [Optional]
+     * @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>;
-    getAllClaims(): Promise<any>;
-    getAllSessions(): Promise<any[]>;
+    getFileComments(fileId: string): Promise<any>;
+    /**
+     * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
+     * @param type
+     * @returns
+     */
+    getAllFilesByType(type: 'KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs'): Promise<FileContent[]>;
+    /**
+     * Delete file by id
+     * @param id
+     * @returns
+     */
     delete(id: string): Promise<any>;
 }
+export {};

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

@@ -0,0 +1,23 @@
+import { KeyPair, DidDocument, FormDataI, RecommendationCredential, Credential, RecommendationFormDataI, VerifiableCredential } from '../../types/credential';
+/**
+ * Create a DID document using the provided key pair.
+ * @param {object} keyPair - The key pair used to create the DID document.
+ * @returns {Promise<object>} The created DID document.
+ */
+export declare const generateDIDSchema: (keyPair: KeyPair) => Promise<DidDocument>;
+/**
+ * Generate an unsigned Verifiable Credential (VC)
+ * @param {object} formData - The form data to include in the VC.
+ * @param {string} issuerDid - The DID of the issuer.
+ * @param {string} vcId - The ID of the credential generated by uuidv4()
+ * @returns {Promise<object>} The created unsigned VC.
+ * @throws Will throw an error if unsigned VC creation fails.
+ */
+export declare function generateUnsignedVC(formData: FormDataI, issuerDid: string, vcId: string): Credential;
+export declare function generateUnsignedRecommendation(recommendation: RecommendationFormDataI, issuerDid: string): RecommendationCredential;
+/**
+ * Extracts the keypair from a Verifiable Credential
+ * @param {Object} credential - The signed Verifiable Credential
+ * @returns {Ed25519VerificationKey2020} keyPair - The generated keypair object
+ */
+export declare function extractKeyPairFromCredential(credential: VerifiableCredential): Promise<KeyPair>;

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

@@ -0,0 +1 @@
+export declare const customDocumentLoader: (url: any) => Promise<any>;

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

@@ -0,0 +1,14 @@
+import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
+/**
+ * keyFile name  = {uuid}-type-timestamp // we need that
+ * vc.id = urn-uuid-{uuid} // we got that
+ * Save data to Google Drive in the specified folder type.
+ * @param {object} data - The data to save.
+ * @param {'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR'} type - The type of data being saved.
+ * @returns {Promise<object>} - The file object saved to Google Drive.
+ * @param {string} uuid - Optional unique identifier for the VC.
+ * @throws Will throw an error if the save operation fails.
+ */
+export declare function saveToGoogleDrive(storage: GoogleDriveStorage, data: any, type: 'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR', uuid?: string): Promise<object>;
+export declare function generateViewLink(fileId: string): string;
+export declare function extractGoogleDriveFileId(url: string): string | null;

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

@@ -0,0 +1,10 @@
+/**
+ * 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/types/utils/saveToGoogle.d.ts

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