@cooperation/vc-storage 1.0.14 → 1.0.16

package/dist/index.js

@@ -3,3 +3,4 @@ export * from './models/CredentialEngine.js';
 export * from './utils/google.js';
 export * from './utils/presentation.js';
 export * from './models/Resume.js';
+export * from './models/ResumeVC.js';

package/dist/models/GoogleDriveStorage.js

@@ -22,10 +22,10 @@ export class GoogleDriveStorage {
         try {
             const res = await fetch(url, {
                 method,
-                headers: new Headers({
+                headers: {
                     Authorization: `Bearer ${this.accessToken}`,
                     ...headers,
-                }),
+                },
                 body,
             });
             // Check the Content-Type to ensure it's JSON before parsing
@@ -104,11 +104,11 @@ export class GoogleDriveStorage {
             }
             // Define file metadata, ensure correct folder is assigned
             const fileMetadata = {
-                name: data.fileName,
+                name: data.fileName || 'resume.json', // Use the provided fileName or default to 'resume.json'
                 parents: [folderId], // Specify the folder ID
-                mimeType: data.mimeType || 'application/json',
+                mimeType: 'application/json', // Ensure the MIME type is set to JSON
             };
-            // make sure the parentId is not in trash
+            // Check if the parent folder is in the trash
             const folder = await this.fetcher({
                 method: 'GET',
                 headers: {},
@@ -117,17 +117,21 @@ export class GoogleDriveStorage {
             if (folder.trashed) {
                 throw new Error('Parent folder is in trash');
             }
-            let uploadUrl = 'https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart';
+            // Prepare the file content as a JSON string
+            const fileContent = JSON.stringify(data);
+            // Create a Blob from the JSON string
+            const fileBlob = new Blob([fileContent], { type: 'application/json' });
+            // Create FormData and append the metadata and file content
             const formData = new FormData();
             formData.append('metadata', new Blob([JSON.stringify(fileMetadata)], { type: 'application/json' }));
-            formData.append('file', new Blob([data.body], { type: fileMetadata.mimeType })); // Set file data and MIME type
+            formData.append('file', fileBlob);
             // Upload file to Google Drive
             console.log('Uploading file...');
             const file = await this.fetcher({
                 method: 'POST',
                 headers: {},
                 body: formData,
-                url: `${uploadUrl}&fields=id,parents`, // Request the file ID and parent folder IDs
+                url: `https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,parents`,
             });
             // Set the file permission to "Anyone with the link" can view
             const permissionUrl = `https://www.googleapis.com/drive/v3/files/${file.id}/permissions`;
@@ -227,58 +231,6 @@ export class GoogleDriveStorage {
         const folders = await this.searchFiles(query);
         return folders.filter((file) => file.mimeType === 'application/vnd.google-apps.folder');
     };
-    /**
-     * Get the last file from folder by folderId
-     * @param folderId
-     * @returns last file content from folder by folderId
-     */
-    findLastFile = async (folderId) => {
-        try {
-            const files = await this.searchFiles(`'${folderId}' in parents`);
-            const fileContents = await Promise.all(files
-                .filter((file) => file.mimeType !== 'application/vnd.google-apps.folder')
-                .map(async (file) => {
-                const content = await this.fetcher({
-                    method: 'GET',
-                    headers: {},
-                    url: `https://www.googleapis.com/drive/v3/files/${file.id}?alt=media`,
-                });
-                return {
-                    ...file,
-                    content,
-                };
-            }));
-            // Find the latest file based on the timestamp in the file name
-            const latestFile = fileContents.reduce((latest, current) => {
-                // Check if the file name has the expected structure
-                const nameParts = current.name.split('_');
-                let currentTimestampStr;
-                if (nameParts.length === 3) {
-                    // Structure with UUID: `${uuid}_${type}_${timestamp}.json`
-                    currentTimestampStr = nameParts[2];
-                }
-                else if (nameParts.length === 2) {
-                    // Structure without UUID: `${type}_${timestamp}.json`
-                    currentTimestampStr = nameParts[1];
-                }
-                else {
-                    // Log warning and skip this file if the structure is not as expected
-                    console.warn(`Unexpected file name format: ${current.name}`);
-                    return latest;
-                }
-                // Parse the timestamp from the file name
-                const latestTimestamp = latest ? parseInt(latest.name.split('_').pop().split('.')[0], 10) : 0;
-                const currentTimestamp = parseInt(currentTimestampStr.split('.')[0], 10);
-                return currentTimestamp > latestTimestamp ? current : latest;
-            }, null);
-            // Return the content of the latest file
-            return latestFile ? latestFile.content : null;
-        }
-        catch (error) {
-            console.error('Error finding last file:', error);
-            return null;
-        }
-    };
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type

package/dist/models/Resume.js

@@ -9,23 +9,16 @@ export class StorageHandler {
         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) {
@@ -41,32 +34,22 @@ 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) {
@@ -94,7 +77,6 @@ export class Resume extends StorageHandler {
             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) {
@@ -105,13 +87,10 @@ export class Resume extends StorageHandler {
         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) {
@@ -119,16 +98,13 @@ export class Resume extends StorageHandler {
         }
     }
     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/models/ResumeVC.js

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

package/dist/types/index.d.ts

@@ -3,3 +3,4 @@ export * from './models/CredentialEngine.js';
 export * from './utils/google.js';
 export * from './utils/presentation.js';
 export * from './models/Resume.js';
+export * from './models/ResumeVC.js';

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

@@ -54,12 +54,6 @@ export declare class GoogleDriveStorage {
      * @returns
      */
     findFolders: (folderId?: string) => Promise<any[]>;
-    /**
-     * Get the last file from folder by folderId
-     * @param folderId
-     * @returns last file content from folder by folderId
-     */
-    findLastFile: (folderId: string) => Promise<any>;
     /**
      * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
      * @param type

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

@@ -1,4 +1,4 @@
-import { GoogleDriveStorage } from './GoogleDriveStorage';
+import { GoogleDriveStorage } from './GoogleDriveStorage.js';
 export declare const resumeFolderTypes: {
     root: string;
     nonSigned: string;
@@ -7,14 +7,11 @@ export declare const resumeFolderTypes: {
 export declare class StorageHandler {
     protected storage: GoogleDriveStorage;
     constructor(storage: GoogleDriveStorage);
-    protected getOrCreateFolder(folderName: string, parentId: string): Promise<any>;
+    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';
@@ -26,7 +23,6 @@ export declare class Resume extends StorageHandler {
     getSignedResumes(): Promise<any[]>;
     getNonSignedResumes(): Promise<any[]>;
     private findRootFolder;
-    private generarteUnsignedResume;
     private isResumeFolderExist;
 }
 export default Resume;

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

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

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

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

package/dist/utils/context.js

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

package/dist/utils/google.js

@@ -29,7 +29,6 @@ export async function saveToGoogleDrive({ storage, data, type }) {
         };
         // Get all root folders
         const rootFolders = await storage.findFolders();
-        console.log('Root folders:', rootFolders);
         // Find or create the "Credentials" folder
         let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
         let credentialsFolderId;
@@ -50,12 +49,11 @@ export async function saveToGoogleDrive({ storage, data, type }) {
             // save the data in Credentials/VCs/VC-timestamp/vc.json
             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;
         }
         // Save the file in the specific subfolder
         const file = await storage.saveFile({ data: fileData, folderId: typeFolderId });
-        console.log(`File uploaded: ${file?.id} under ${type}s with ID ${typeFolderId} folder in Credentials folder`);
+        console.log('🚀 ~ file:', file);
         return file;
     }
     catch (error) {
@@ -75,7 +73,6 @@ export async function uploadImageToGoogleDrive(storage, imageFile) {
         const rootFolders = await storage.findFolders();
         let credentialsFolder = rootFolders.find((f) => f.name === 'Credentials');
         if (!credentialsFolder) {
-            console.log('Credentials folder not found. Creating...');
             credentialsFolder = await storage.createFolder({ folderName: 'Credentials', parentFolderId: 'root' });
         }
         const credentialsFolderId = credentialsFolder.id;
@@ -96,7 +93,7 @@ export async function uploadImageToGoogleDrive(storage, imageFile) {
             data: imageData,
             folderId: mediasFolderId,
         });
-        console.log(`Image uploaded: ${uploadedImage?.id} to MEDIAs folder in Credentials`);
+        console.log('🚀 ~ uploadedImage:', uploadedImage);
         return uploadedImage;
     }
     catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.14",
+	"version": "1.0.16",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",