@cooperation/vc-storage 1.0.1 → 1.0.5

package/dist/utils/credential.js

@@ -0,0 +1,172 @@
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * 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 const generateDIDSchema = async (keyPair) => {
+    try {
+        const DID = keyPair.controller;
+        const didDocument = {
+            '@context': ['https://www.w3.org/ns/did/v1'],
+            id: DID,
+            publicKey: [
+                {
+                    id: keyPair.id,
+                    type: 'Ed25519VerificationKey2020',
+                    controller: DID,
+                    publicKeyMultibase: keyPair.publicKeyMultibase,
+                },
+            ],
+            authentication: [keyPair.id],
+            assertionMethod: [keyPair.id],
+            capabilityDelegation: [keyPair.id],
+            capabilityInvocation: [keyPair.id],
+            keyAgreement: [
+                {
+                    id: `${keyPair.id}-keyAgreement`,
+                    type: 'X25519KeyAgreementKey2020',
+                    controller: DID,
+                    publicKeyMultibase: keyPair.publicKeyMultibase,
+                },
+            ],
+        };
+        return didDocument;
+    }
+    catch (error) {
+        console.error('Error creating DID document:', error);
+        throw error;
+    }
+};
+/**
+ * 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 function generateUnsignedVC(formData, issuerDid, vcId) {
+    try {
+        const issuanceDate = new Date().toISOString();
+        if (issuanceDate > formData.expirationDate)
+            throw Error('issuanceDate cannot be after expirationDate');
+        const unsignedCredential = {
+            '@context': [
+                'https://www.w3.org/2018/credentials/v1',
+                'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
+                {
+                    duration: 'https://schema.org/duration',
+                    fullName: 'https://schema.org/name',
+                    portfolio: 'https://schema.org/portfolio',
+                    evidenceLink: 'https://schema.org/evidenceLink',
+                    evidenceDescription: 'https://schema.org/evidenceDescription',
+                    credentialType: 'https://schema.org/credentialType',
+                },
+            ],
+            id: `urn:uuid:${vcId}`, //! i want this uuid to be in the condition where vcId part == keypair file name which is like this `${uuid ? uuid + '_' : ''}${type}_${timestamp}.json`,
+            type: ['VerifiableCredential', 'OpenBadgeCredential'],
+            issuer: {
+                id: issuerDid,
+                type: ['Profile'],
+            },
+            issuanceDate,
+            expirationDate: formData.expirationDate,
+            credentialSubject: {
+                type: ['AchievementSubject'],
+                name: formData.fullName,
+                portfolio: formData.portfolio,
+                evidenceLink: formData.evidenceLink,
+                evidenceDescription: formData.achievementDescription,
+                duration: formData.duration,
+                credentialType: formData.credentialType,
+                achievement: [
+                    {
+                        id: `urn:uuid:${uuidv4()}`,
+                        type: ['Achievement'],
+                        criteria: {
+                            narrative: formData.criteriaNarrative,
+                        },
+                        description: formData.achievementDescription,
+                        name: formData.achievementName,
+                        image: formData.evidenceLink
+                            ? {
+                                id: formData.evidenceLink,
+                                type: 'Image',
+                            }
+                            : undefined,
+                    },
+                ],
+            },
+        };
+        return unsignedCredential;
+    }
+    catch (error) {
+        console.error('Error creating unsigned VC', error);
+        throw error;
+    }
+}
+export function generateUnsignedRecommendation(recommendation, issuerDid) {
+    try {
+        const issuanceDate = new Date().toISOString();
+        if (issuanceDate > recommendation.expirationDate)
+            throw Error('issuanceDate cannot be after expirationDate');
+        const unsignedRecommendation = {
+            '@context': [
+                'https://www.w3.org/2018/credentials/v1',
+                'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json',
+                {
+                    howKnow: 'https://schema.org/howKnow',
+                    recommendationText: 'https://schema.org/recommendationText',
+                    qualifications: 'https://schema.org/qualifications',
+                    explainAnswer: 'https://schema.org/explainAnswer',
+                    portfolio: 'https://schema.org/portfolio',
+                },
+            ],
+            id: `urn:uuid:${uuidv4()}`, // Unique identifier for the recommendation
+            type: ['VerifiableCredential', 'https://schema.org/RecommendationCredential'], // Use a fully qualified URI for 'RecommendationCredential'
+            issuer: {
+                id: issuerDid,
+                type: ['Profile'],
+            },
+            issuanceDate,
+            expirationDate: recommendation.expirationDate,
+            credentialSubject: {
+                name: recommendation.fullName,
+                howKnow: recommendation.howKnow,
+                recommendationText: recommendation.recommendationText,
+                qualifications: recommendation.qualifications,
+                explainAnswer: recommendation.explainAnswer,
+                portfolio: recommendation.portfolio.map((item) => ({
+                    name: item.name,
+                    url: item.url,
+                })),
+            },
+        };
+        console.log('Successfully created Unsigned Recommendation', unsignedRecommendation);
+        return unsignedRecommendation;
+    }
+    catch (error) {
+        console.error('Error creating unsigned recommendation', error);
+        throw error;
+    }
+}
+/**
+ * Extracts the keypair from a Verifiable Credential
+ * @param {Object} credential - The signed Verifiable Credential
+ * @returns {Ed25519VerificationKey2020} keyPair - The generated keypair object
+ */
+export async function extractKeyPairFromCredential(credential) {
+    const verificationMethod = credential.proof.verificationMethod;
+    const issuer = credential.issuer.id;
+    // Example of extracting the public key from the DID fragment (verification method)
+    const publicKeyMultibase = verificationMethod.split('#')[1];
+    // Generate the keypair using Ed25519VerificationKey2020
+    const keyPair = await Ed25519VerificationKey2020.from({
+        id: verificationMethod,
+        controller: issuer,
+        publicKeyMultibase: publicKeyMultibase,
+    });
+    return keyPair;
+}

package/dist/utils/digitalbazaar.js

@@ -0,0 +1,37 @@
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+import { driver as didKeyDriver } from '@digitalbazaar/did-method-key';
+import { defaultDocumentLoader } from '@digitalbazaar/vc';
+import { localOBContext, localED25519Context } from '../utils/context.js';
+// Initialize the DID method key driver
+const didKeyDriverInstance = didKeyDriver();
+didKeyDriverInstance.use({
+    multibaseMultikeyHeader: 'z6Mk',
+    fromMultibase: Ed25519VerificationKey2020.from,
+});
+// Custom document loader
+export const customDocumentLoader = async (url) => {
+    // Context map for local contexts
+    const contextMap = {
+        'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json': localOBContext,
+        'https://w3id.org/security/suites/ed25519-2020/v1': localED25519Context,
+    };
+    // Return local context if it matches the URL
+    if (contextMap[url]) {
+        return {
+            contextUrl: null,
+            documentUrl: url,
+            document: contextMap[url],
+        };
+    }
+    // Handle did:key resolution
+    if (url.startsWith('did:key:')) {
+        const didDocument = await didKeyDriverInstance.get({ did: url });
+        return {
+            contextUrl: null,
+            documentUrl: url,
+            document: didDocument,
+        };
+    }
+    // Fallback to the default document loader for unknown URLs
+    return defaultDocumentLoader(url);
+};

package/dist/utils/google.js

@@ -0,0 +1,79 @@
+/**
+ * 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 async function saveToGoogleDrive(storage, data, type, uuid) {
+    try {
+        const timestamp = Date.now();
+        const fileData = {
+            fileName: `${uuid ? uuid + '_' : ''}${type}_${timestamp}.json`,
+            mimeType: 'application/json',
+            body: JSON.stringify(data),
+        };
+        // Get all root folders
+        const rootFolders = await storage.findFolders();
+        console.log('Root folders:', rootFolders);
+        // Find or create the "Credentials" folder
+        let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
+        let credentialsFolderId;
+        if (!credentialsFolder) {
+            credentialsFolderId = await storage.createFolder('Credentials');
+            console.log('Created Credentials folder with ID:', credentialsFolderId);
+        }
+        else {
+            credentialsFolderId = credentialsFolder.id;
+            console.log('Found Credentials folder with ID:', credentialsFolderId);
+        }
+        // Get subfolders within the "Credentials" folder
+        const subfolders = await storage.findFolders(credentialsFolderId);
+        console.log(`Subfolders in Credentials (ID: ${credentialsFolderId}):`, subfolders);
+        // Find or create the specific subfolder (DIDs or VCs)
+        let typeFolder = subfolders.find((f) => f.name === `${type}s`);
+        let typeFolderId;
+        if (!typeFolder) {
+            typeFolderId = await storage.createFolder(`${type}s`, credentialsFolderId);
+            console.log(`Created ${type}s folder with ID:`, typeFolderId);
+        }
+        else {
+            typeFolderId = typeFolder.id;
+            console.log(`Found ${type} files:`, await storage.findLastFile(typeFolderId));
+            console.log(`Found ${type}s folder with ID:`, typeFolderId);
+        }
+        // Save the file in the specific subfolder
+        const file = await storage.save(fileData, typeFolderId);
+        console.log(`File uploaded: ${file?.id} under ${type}s with ID ${typeFolderId} folder in Credentials folder`);
+        if (file && file.id) {
+            console.log('Sharing file with second user...');
+            await storage.addCommenterRoleToFile(file.id);
+        }
+        return file;
+    }
+    catch (error) {
+        console.error('Error saving to Google Drive:', error);
+        throw error;
+    }
+}
+export function generateViewLink(fileId) {
+    if (!fileId) {
+        throw new Error('File ID is required to generate a view link.');
+    }
+    // Construct the view URL based on the file ID
+    return `https://drive.google.com/file/d/${fileId}/view`;
+}
+export function extractGoogleDriveFileId(url) {
+    const regex = /\/d\/([a-zA-Z0-9_-]+)\//;
+    const match = url.match(regex);
+    if (match && match[1]) {
+        return match[1]; // Return the file ID
+    }
+    else {
+        console.error('Invalid Google Drive URL: File ID not found.');
+        return null;
+    }
+}

package/dist/utils/presentation.js

@@ -0,0 +1,48 @@
+import { CredentialEngine } from '../models/CredentialEngine.js';
+import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
+import { extractGoogleDriveFileId } from './google.js';
+/**
+ * Create and sign a Verifiable Presentation (VP) from a given Verifiable Credential (VC) file and any associated recommendations.
+ * @param {string} accessTokens - The access tokens for the user.
+ * @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 = [];
+        // 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, ...recommendations]); //! do not edit the array order!!
+        // Use the key pair to sign the presentation
+        const signedPresentation = await engine.signPresentation(presentation);
+        return { signedPresentation };
+    }
+    catch (error) {
+        console.error('Error during Verifiable Presentation creation and signing:', error);
+        return null;
+    }
+};

package/dist/utils/saveToGoogle.js

@@ -2,6 +2,7 @@
  * Save data to Google Drive in the specified folder type.
  * @param {object} data - The data to save.
  * @param {'VC' | 'DID' | 'UnsignedVC'} type - The type of data being saved.
+ * @returns {Promise<object>} - The file object saved to Google Drive.
  * @throws Will throw an error if the save operation fails.
  */
 export async function saveToGoogleDrive(storage, data, type) {
@@ -44,6 +45,10 @@ export async function saveToGoogleDrive(storage, data, type) {
         // Save the file in the specific subfolder
         const file = await storage.save(fileData, typeFolderId);
         console.log(`File uploaded: ${file?.id} under ${type}s with ID ${typeFolderId} folder in Credentials folder`);
+        if (file && file.id) {
+            console.log('Sharing file with second user...');
+            await storage.addCommenterRoleToFile(file.id);
+        }
         return file;
     }
     catch (error) {
@@ -51,3 +56,10 @@ export async function saveToGoogleDrive(storage, data, type) {
         throw error;
     }
 }
+export function generateViewLink(fileId) {
+    if (!fileId) {
+        throw new Error('File ID is required to generate a view link.');
+    }
+    // Construct the view URL based on the file ID
+    return `https://drive.google.com/file/d/${fileId}/view`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.1",
+	"version": "1.0.5",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -16,6 +16,8 @@
 	"author": "cooperation",
 	"license": "ISC",
 	"dependencies": {
+		"@cooperation/vc-storage": "^1.0.4",
+		"@digitalbazaar/did-method-key": "^5.2.0",
 		"@digitalbazaar/ed25519-signature-2020": "^5.3.0",
 		"@digitalbazaar/ed25519-verification-key-2020": "^4.1.0",
 		"@digitalbazaar/vc": "^6.3.0",
@@ -26,7 +28,8 @@
 	"devDependencies": {
 		"@types/fs-extra": "^11.0.4",
 		"@types/jest": "^29.5.12",
-		"typescript": "^5.5.4"
+		"@types/uuid": "^10.0.0",
+		"typescript": "^5.6.2"
 	},
 	"jest": {
 		"preset": "ts-jest",

package/dist/models/CredentialVerefier.js

@@ -1,36 +0,0 @@
-import { Ed25519Signature2020 } from '@digitalbazaar/ed25519-signature-2020';
-// import { verifyCredential } from '@digitalbazaar/vc';
-import { customDocumentLoader } from './CredentialEngine';
-export class CredentialVerifier {
-    /**
-     * Verify a signed Verifiable Credential (VC)
-     * @param {object} signedVC - The signed VC to verify.
-     * @returns {Promise<boolean>} True if the VC is valid, false otherwise.
-     * @throws Will throw an error if VC verification fails.
-     */
-    async verifyVC(signedVC, keyPair) {
-        const suite = new Ed25519Signature2020({
-            key: keyPair,
-            verificationMethod: keyPair.id,
-        });
-        try {
-            const result = await verifyCredential({
-                credential: signedVC,
-                suite,
-                documentLoader: customDocumentLoader,
-            });
-            if (result.verified) {
-                console.log('VC verification successful');
-                return true;
-            }
-            else {
-                console.log('VC verification failed', result);
-                return false;
-            }
-        }
-        catch (error) {
-            console.error('Error verifying VC:', error);
-            throw error;
-        }
-    }
-}

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

@@ -1,9 +0,0 @@
-export declare class CredentialVerifier {
-    /**
-     * Verify a signed Verifiable Credential (VC)
-     * @param {object} signedVC - The signed VC to verify.
-     * @returns {Promise<boolean>} True if the VC is valid, false otherwise.
-     * @throws Will throw an error if VC verification fails.
-     */
-    verifyVC(signedVC: Credential, keyPair: any): Promise<boolean>;
-}