@cooperation/vc-storage 1.0.0

package/README.md

@@ -0,0 +1,136 @@
+# Trust Storage Library
+
+Store your files using up to three strategies. Currently, we offer the GoogleDriveStorage class, which is designed for storing files in Google Drive. Stay tuned for additional methods coming soon 😊
+
+## Installation
+
+To install the Trust Storage library, you can use either npm or yarn. Run one of the following commands in your project directory:
+
+```bash
+npm install trust_storage
+```
+
+or
+
+```bash
+yarn add trust_storage
+```
+
+## Usage
+
+To use the `GoogleDriveStorage` class in your application, you need to pass an access token that has appropriate permissions for Google Drive operations. You can generate an access token by following these steps:
+
+1. Visit the [OAuth 2.0 Playground](https://developers.google.com/oauthplayground/).
+2. Enter the scope: `https://www.googleapis.com/auth/drive`.
+3. Copy the accessToken and pass it to the `GoogleDriveStorage` class.
+
+The `GoogleDriveStorage` class includes two methods:
+
+- `createFolder()`: It is designed to create a new folder in Google Drive.
+- `uploadFile()`: Ensure that the necessary folder has been created or identified where the file will be stored.
+
+## Notes
+
+- This library is a demonstration tool for uploading files to Google Drive.
+
+### Your First Code Contribution
+
+1. Clone the repository.
+2. Run yarn or npm install to install dependencies.
+3. Create a new branch for your feature or bugfix.
+4. Make your changes.
+5. Commit your changes and push your branch to your fork.
+6. Open a pull request.
+
+### Pull Requests
+
+When you're ready to submit your pull request:
+
+1. Ensure your work is aligned with the project's coding standards.
+2. Fill out the pull request template.
+3. Include a clear and detailed description of the changes.
+4. Link any related issues.
+5. Wait for review and address any feedback.
+
+## Development Workflow
+
+### Setup
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/yourusername/your-repo-name.git
+   ```
+2. Navigate to the project directory:
+   ```bash
+   cd your-repo-name
+   ```
+3. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+Certainly! Here is the provided text rewritten in `.md` format:
+
+````markdown
+## Publishing Flow
+
+If you want to publish a new version of the package, please follow these steps:
+
+### Request Access
+
+Ask for access to publish the package in the Slack. Mention the version and any significant changes.
+
+### Update Version
+
+Ensure you update the version in `package.json` according to [Semantic Versioning](https://semver.org/). You can do this manually or using the npm command:
+
+```bash
+npm version [patch|minor|major]
+```
+````
+
+### Ensure Tests Pass
+
+Run all tests to make sure they are passing:
+
+```bash
+npm test
+```
+
+### Build the Project
+
+Build the project to ensure all changes are compiled:
+
+```bash
+npm run build
+```
+
+### Commit and Push
+
+Commit and push your changes to the main branch:
+
+```bash
+git add .
+git commit -m "Prepare for release vX.Y.Z"
+git push origin main
+```
+
+### Login to npm
+
+If you are not already logged in, log in to npm using your credentials:
+
+```bash
+npm login
+```
+
+### Publish the Package
+
+Once you have access and everything is set, publish the package:
+
+```bash
+npm publish
+```
+
+### Notify Team
+
+Inform the team in the Slack channel that the new version has been published.

package/dist/index.js

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

package/dist/models/CredentialEngine.js

@@ -0,0 +1,187 @@
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+import { Ed25519Signature2020 } from '@digitalbazaar/ed25519-signature-2020';
+import { defaultDocumentLoader, issue } from '@digitalbazaar/vc';
+import { v4 as uuidv4 } from 'uuid';
+import { localOBContext, localED25519Context } from '../utils/context.js';
+// Custom document loader
+export const customDocumentLoader = async (url) => {
+    const contextMap = {
+        'https://purl.imsglobal.org/spec/ob/v3p0/context-3.0.3.json': localOBContext,
+        'https://w3id.org/security/suites/ed25519-2020/v1': localED25519Context,
+    };
+    if (contextMap[url]) {
+        return {
+            contextUrl: null,
+            documentUrl: url,
+            document: contextMap[url],
+        };
+    }
+    return defaultDocumentLoader(url); // Fallback to default loader for unknown URLs
+};
+export 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.
+     */
+    async generateDIDSchema(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;
+        }
+    }
+    /**
+     * 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() {
+        try {
+            const keyPair = await Ed25519VerificationKey2020.generate();
+            keyPair.controller = `did:key:${keyPair.publicKeyMultibase}`;
+            keyPair.id = `${keyPair.controller}#${keyPair.publicKeyMultibase}`;
+            keyPair.revoked = false;
+            const didDocument = await this.generateDIDSchema(keyPair);
+            return { didDocument, keyPair };
+        }
+        catch (error) {
+            console.error('Error creating DID:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a new DID with user metamask address as controller
+     * @param walletrAddress
+     * @returns {Promise<{didDocument: object, keyPair: object}>} The created DID document and key pair.
+     * @throws Will throw an error if DID creation fails.
+     */
+    async createWalletDID(walletrAddress) {
+        try {
+            const keyPair = await Ed25519VerificationKey2020.generate();
+            keyPair.controler = walletrAddress; // Using the MetaMask address as controller
+            keyPair.id = `${keyPair.controller}#${keyPair.fingerprint()}`;
+            keyPair.revoked = false;
+            const didDocument = await this.generateDIDSchema(keyPair);
+            return { didDocument, keyPair };
+        }
+        catch (error) {
+            console.error('Error creating DID:', error);
+            throw error;
+        }
+    }
+    /**
+     * 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.
+     */
+    async createUnsignedVC(formData, issuerDid) {
+        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:${uuidv4()}`, // Add the id property
+                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,
+                        },
+                    ],
+                },
+            };
+            console.log('Successfully created Unsigned Credentials', unsignedCredential);
+            return unsignedCredential;
+        }
+        catch (error) {
+            console.error('Error creating unsigned VC', error);
+            throw error;
+        }
+    }
+    /**
+     * 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.
+     * @throws Will throw an error if VC signing fails.
+     */
+    async signVC(credential, keyPair) {
+        const suite = new Ed25519Signature2020({ key: keyPair, verificationMethod: keyPair.id });
+        try {
+            const signedVC = await issue({ credential, suite, documentLoader: customDocumentLoader });
+            console.log('Successfully created Signed VC', signedVC);
+            return signedVC;
+        }
+        catch (error) {
+            console.error('Error signing VC:', error);
+            throw error;
+        }
+    }
+}

package/dist/models/CredentialVerefier.js

@@ -0,0 +1,36 @@
+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/models/GoogleDriveStorage.js

@@ -0,0 +1,174 @@
+export class GoogleDriveStorage {
+    accessToken;
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    async fetcher({ method, headers, body, url }) {
+        try {
+            const res = await fetch(url, {
+                method,
+                headers: new Headers({
+                    Authorization: `Bearer ${this.accessToken}`,
+                    ...headers,
+                }),
+                body,
+            });
+            const data = await res.json();
+            if (!res.ok) {
+                throw new Error(data.error.message);
+            }
+            return data;
+        }
+        catch (error) {
+            console.error('Error fetching data:', error);
+            throw error;
+        }
+    }
+    // New method to encapsulate search logic
+    async searchFiles(query) {
+        const result = await this.fetcher({
+            method: 'GET',
+            headers: {},
+            url: `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&trashed=false&fields=files(id,name,mimeType,parents)`,
+        });
+        return result.files;
+    }
+    async createFolder(folderName, parentFolderId) {
+        const metadata = {
+            name: folderName,
+            mimeType: 'application/vnd.google-apps.folder',
+            parents: parentFolderId ? [parentFolderId] : [],
+        };
+        const folder = await this.fetcher({
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(metadata),
+            url: 'https://www.googleapis.com/drive/v3/files',
+        });
+        console.log('Folder ID:', folder.id);
+        return folder.id;
+    }
+    async save(data, folderId) {
+        try {
+            const fileMetadata = {
+                name: data.fileName,
+                mimeType: data.mimeType,
+                parents: [folderId],
+            };
+            const formData = new FormData();
+            formData.append('metadata', new Blob([JSON.stringify(fileMetadata)], { type: 'application/json' }));
+            formData.append('file', data.body);
+            const file = await this.fetcher({
+                method: 'POST',
+                headers: {},
+                body: formData,
+                url: 'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart',
+            });
+            console.log('File uploaded:', file.id);
+            return file;
+        }
+        catch (error) {
+            console.error('Error uploading file:', error);
+            return null;
+        }
+    }
+    async retrieve(id) {
+        try {
+            const file = await this.fetcher({
+                method: 'GET',
+                headers: {},
+                url: `https://www.googleapis.com/drive/v3/files/${id}?alt=media`,
+            });
+            console.log('File retrieved:', file);
+            return file;
+        }
+        catch (error) {
+            console.error('Error retrieving file:', error);
+            return null;
+        }
+    }
+    findFolders = async (id) => {
+        const query = id
+            ? `'${id}' 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');
+    };
+    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,
+                };
+            }));
+            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);
+                return currentTimestamp > latestTimestamp ? current : latest;
+            }, null);
+            return latestFile ? latestFile.content : null;
+        }
+        catch (error) {
+            console.error('Error finding last file:', error);
+            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() {
+        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 sessionsFolder = subfolders.find((f) => f.name === 'Sessions');
+        if (!sessionsFolder)
+            return [];
+        const sessions = 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)`,
+        });
+        return sessions;
+    }
+    async delete(id) {
+        try {
+            const response = await this.fetcher({
+                method: 'DELETE',
+                headers: {},
+                url: `https://www.googleapis.com/drive/v3/files/${id}`,
+            });
+            console.log('File deleted:', response);
+            return response;
+        }
+        catch (error) {
+            console.error('Error deleting file:', error);
+            return null;
+        }
+    }
+}

package/dist/models/StorageContext.js

@@ -0,0 +1,50 @@
+// import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+// import { StorageStrategy, StorageType } from '../../types/index.js';
+// class StorageContext {
+// 	public strategy: StorageStrategy;
+// 	constructor(strategy: StorageStrategy) {
+// 		this.strategy = strategy;
+// 	}
+// 	setStrategy(strategy: StorageStrategy) {
+// 		this.strategy = strategy;
+// 	}
+// 	async createFolder(folderName: string, parentFolderId?: string) {
+// 		return this.strategy.createFolder(folderName, parentFolderId);
+// 	}
+// 	async save(data: any, folderId: string) {
+// 		return this.strategy.save(data, folderId);
+// 	}
+// 	async retrieve(id: string) {
+// 		return this.strategy.retrieve(id);
+// 	}
+// 	async findFolders(id?: string) {
+// 		return this.strategy.findFolders(id);
+// 	}
+// 	async findLastFile(folderId: string) {
+// 		return this.strategy.findLastFile(folderId);
+// 	}
+// 	async getAllClaims() {
+// 		return this.strategy.getAllClaims();
+// 	}
+// 	async getAllSessions() {
+// 		return this.strategy.getAllSessions();
+// 	}
+// 	async getFileContent(fileId: string) {
+// 		return this.strategy.getFileContent(fileId);
+// 	}
+// }
+// class StorageFactory {
+// 	static getStorageStrategy(type: StorageType, options: any): StorageStrategy {
+// 		switch (type) {
+// 			case 'googleDrive':
+// 				const { accessToken } = options;
+// 				if (!accessToken) {
+// 					throw new Error('Missing required parameters');
+// 				}
+// 				return new GoogleDriveStorage(accessToken);
+// 			default:
+// 				throw new Error('Unsupported storage type');
+// 		}
+// 	}
+// }
+// export { StorageContext, StorageFactory };

package/dist/types/index.d.ts

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

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

@@ -0,0 +1,45 @@
+import { KeyPair, FormDataI, Credential, DidDocument } from '../../types/Credential.js';
+export declare const customDocumentLoader: (url: string) => Promise<any>;
+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;
+    /**
+     * 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(): Promise<{
+        didDocument: DidDocument;
+        keyPair: KeyPair;
+    }>;
+    /**
+     * Create a new DID with user metamask address as controller
+     * @param walletrAddress
+     * @returns {Promise<{didDocument: object, keyPair: object}>} The created DID document and key pair.
+     * @throws Will throw an error if DID creation fails.
+     */
+    createWalletDID(walletrAddress: string): Promise<{
+        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.
+     * @throws Will throw an error if VC signing fails.
+     */
+    signVC(credential: Credential, keyPair: KeyPair): Promise<Credential>;
+}

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

@@ -0,0 +1,9 @@
+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>;
+}

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

@@ -0,0 +1,17 @@
+import { DataToSaveI } from '../../types';
+export declare class GoogleDriveStorage {
+    private accessToken;
+    constructor(accessToken: string);
+    private fetcher;
+    private searchFiles;
+    createFolder(folderName: string, parentFolderId?: string): Promise<string>;
+    save(data: DataToSaveI, folderId: string): Promise<{
+        id: string;
+    } | null>;
+    retrieve(id: string): Promise<any>;
+    findFolders: (id?: string) => Promise<any[]>;
+    findLastFile: (folderId: string) => Promise<any>;
+    getAllClaims(): Promise<any>;
+    getAllSessions(): Promise<any>;
+    delete(id: string): Promise<any>;
+}