@cooperation/vc-storage 1.0.34 → 1.0.41

package/dist/models/StorageContext.js

@@ -1,50 +1,15 @@
-// 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 };
+import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+import { WASZcapStorage } from './WASZcapStorage.js';
+export function createStorage(kind, options) {
+    if (kind === 'googleDrive') {
+        if (!options?.accessToken)
+            throw new Error('Missing accessToken for Google Drive');
+        return new GoogleDriveStorage(options.accessToken);
+    }
+    if (kind === 'wasZcap') {
+        if (!options?.appInstance || !options?.capability)
+            throw new Error('Missing appInstance or capability for WAS Zcap');
+        return new WASZcapStorage({ appInstance: options.appInstance, capability: options.capability });
+    }
+    throw new Error('Unsupported storage kind');
+}

package/dist/models/WASStorage.js

@@ -0,0 +1,71 @@
+import { StorageClient } from '@wallet.storage/fetch-client';
+import { WAS_BASE_URL } from '../../app.config.js';
+export class LCWStorage {
+    static storageClient;
+    signer;
+    zcap;
+    spaceId;
+    constructor({ signer, zcap, spaceId }) {
+        this.signer = signer;
+        this.zcap = zcap;
+        this.spaceId = spaceId;
+    }
+    getStorageClient() {
+        if (!LCWStorage.storageClient) {
+            LCWStorage.storageClient = new StorageClient(new URL(WAS_BASE_URL));
+        }
+        return LCWStorage.storageClient;
+    }
+    getResource(key) {
+        const space = this.getStorageClient().space({
+            signer: this.signer,
+            id: this.spaceId,
+        });
+        return space.resource(key);
+    }
+    async add(key, value) {
+        const resource = this.getResource(key);
+        const blob = new Blob([JSON.stringify(value)], {
+            type: 'application/json',
+        });
+        const res = await resource.put(blob, {
+            signer: this.signer,
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to add resource. Status: ${res.status}`);
+        }
+        return res;
+    }
+    async read(key) {
+        const resource = this.getResource(key);
+        const res = await resource.get({ signer: this.signer });
+        if (!res.ok) {
+            if (res.status === 404)
+                return null;
+            throw new Error(`Failed to read resource. Status: ${res.status}`);
+        }
+        return await res.json();
+    }
+    async update(key, value) {
+        return this.add(key, value); // Overwrite = update
+    }
+    async delete(key) {
+        const resource = this.getResource(key);
+        const res = await resource.delete({ signer: this.signer });
+        if (!res.ok && res.status !== 404) {
+            throw new Error(`Failed to delete resource. Status: ${res.status}`);
+        }
+        return true;
+    }
+    async list() {
+        // const space = this.getStorageClient().space({
+        //   signer: this.signer,
+        //   id: this.spaceId as `urn:uuid:${string}`,
+        // });
+        // const res = await space.resources().list({ signer: this.signer });
+        // if (!res.ok) {
+        //   throw new Error(`Failed to list resources. Status: ${res.status}`);
+        // }
+        // return await res.json(); // Should contain list of resource IDs or summaries
+    }
+}

package/dist/models/WASZcapStorage.js

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import { ZcapClient } from '@digitalcredentials/ezcap';
+import { Ed25519VerificationKey2020 } from '@digitalcredentials/ed25519-verification-key-2020';
+import { Ed25519Signature2020 } from '@digitalcredentials/ed25519-signature-2020';
+export class WASZcapStorage {
+    zcapClient;
+    capability;
+    ready;
+    constructor(config) {
+        if (!config?.appInstance?.publicKeyMultibase || !config?.appInstance?.privateKeyMultibase) {
+            throw new Error('appInstance is missing key material');
+        }
+        if (!config?.capability) {
+            throw new Error('capability (zcap) is required');
+        }
+        this.capability = config.capability;
+        this.ready = this.initClient(config.appInstance);
+    }
+    async initClient(appInstance) {
+        const key = await Ed25519VerificationKey2020.from(appInstance);
+        const signer = key.signer();
+        // ezcap expects invocationSigner.id
+        this.zcapClient = new ZcapClient({
+            SuiteClass: Ed25519Signature2020,
+            invocationSigner: signer,
+        });
+    }
+    async request(method, url, body) {
+        await this.ready;
+        return this.zcapClient.request({
+            url,
+            capability: this.capability,
+            method,
+            action: method,
+            ...(body ? { blob: body } : {}),
+        });
+    }
+    buildUrlForKey(key) {
+        const baseUrl = this.capability?.invocationTarget;
+        if (!baseUrl)
+            throw new Error('Capability invocationTarget is missing');
+        return `${baseUrl}/${encodeURIComponent(key)}`;
+    }
+    async upload({ key, file }) {
+        const url = this.buildUrlForKey(key);
+        const res = await this.request('PUT', url, file);
+        return this.extractId(res) ?? url;
+    }
+    async read(key) {
+        const url = this.buildUrlForKey(key);
+        const res = await this.request('GET', url);
+        if (res?.status === 404)
+            return null;
+        try {
+            return await res.json();
+        }
+        catch (err) {
+            console.error('Error reading file:', err);
+        }
+    }
+    async delete(key) {
+        const url = this.buildUrlForKey(key);
+        const res = await this.request('DELETE', url);
+        return res?.ok || res?.status === 404;
+    }
+    // Updates can be performed by calling upload() with the same key
+    extractId(res) {
+        return res?.id || res?.result?.id || res?.url;
+    }
+}

package/dist/scripts/test-was.js

@@ -0,0 +1,61 @@
+import { Ed25519Signer } from '@did.coop/did-key-ed25519';
+import { v4 as uuidv4 } from 'uuid';
+import { LCWStorage } from '../models/WASStorage.js';
+import { StorageClient } from '@wallet.storage/fetch-client';
+import { WAS_BASE_URL } from '../../app.config.js';
+async function main() {
+    const appDidSigner = await Ed25519Signer.generate();
+    console.log('Signer:', appDidSigner);
+    const spaceUUID = uuidv4();
+    const spaceId = `urn:uuid:${spaceUUID}`;
+    console.log('Space ID:', spaceId);
+    const storage = new StorageClient(new URL(WAS_BASE_URL));
+    const space = storage.space({
+        signer: appDidSigner,
+        id: spaceId,
+    });
+    const spaceObject = {
+        id: spaceId,
+        controller: appDidSigner.id.split('#')[0],
+    };
+    console.log('Creating space with object:', spaceObject);
+    const spaceObjectBlob = new Blob([JSON.stringify(spaceObject)], { type: 'application/json' });
+    // Create the space
+    const response = await space.put(spaceObjectBlob, {
+        signer: appDidSigner,
+    });
+    console.log('🚀 ~ main ~ response:', response);
+    console.log('Space PUT response:', {
+        status: response.status,
+        ok: response.ok,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to initialize space. Status: ${response.status}`);
+    }
+    // Store the signer for future connections
+    const signerJson = await appDidSigner.toJSON();
+    console.log('Signer JSON:', signerJson);
+    const lcwStorage = new LCWStorage({ signer: appDidSigner, zcap: {}, spaceId });
+    const res = await lcwStorage.add('test', { test: 'test' });
+    if (res.ok) {
+        console.log('Record added successfully');
+    }
+    else {
+        console.error('Failed to add record');
+    }
+    const res2 = await lcwStorage.read('test');
+    if (res2) {
+        console.log('Record read successfully');
+    }
+    else {
+        console.error('Failed to read record');
+    }
+    const res3 = await lcwStorage.update('test', { test: 'test2' });
+    if (res3.ok) {
+        console.log('Record updated successfully');
+    }
+    else {
+        console.error('Failed to update record');
+    }
+}
+main();

package/dist/types/index.d.ts

@@ -1,6 +1,10 @@
 export * from './models/GoogleDriveStorage.js';
 export * from './models/CredentialEngine.js';
 export * from './utils/google.js';
-export * from './utils/presentation.js';
 export * from './models/Resume.js';
 export * from './models/ResumeVC.js';
+export * from './models/WASStorage.js';
+export * from './models/WASZcapStorage.js';
+export * from './models/StorageContext.js';
+export * from './utils/createWASSpace.js';
+export * from './utils/getOrCreateAppDID.js';

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

@@ -50,7 +50,7 @@ export declare class CredentialEngine {
     }>;
     /**
      * Sign a Verifiable Credential (VC)
-     * @param {'VC' | 'RECOMMENDATION'} type - The signature type.
+     * @param {'VC' | 'RECOMMENDATION' | 'EMPLOYMENT' | 'VOLUNTEERING' | 'PERFORMANCE_REVIEW'} 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.
      * @param {FormDataI | RecommendationFormDataI} formData - The form data to include in the VC.

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

@@ -3,70 +3,64 @@ type FileType = 'KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs' | '
  * @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 saveFile - Save a file to 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 createFolder - Create a new folder in Google Drive
+ * @method getOrCreateMediaFolder - Get the ID of the MEDIAs folder
+ * @method uploadBinaryFile - Upload a binary file to Google Drive
+ * @method updateFileData - Update the data of a file
+ * @method updateRelationsFile - Update the relations file
  * @method delete - Delete a file from Google Drive
+ * @method checkEmailExists - Check if an email VC exists and return its content
+ * @method findFolders - Find folders in Google Drive
+ * @method findFolderFiles - Find files in a folder
  */
 export declare class GoogleDriveStorage {
     private accessToken;
-    folderCache: any;
-    private fileIdsCache;
-    private updateFileIdsJson;
+    static folderCache: any;
+    private static fileIdsCache;
     constructor(accessToken: string);
+    private updateFileIdsJson;
     private fetcher;
     private getFileContent;
     private searchFiles;
+    private getOrCreateMediaFolder;
+    findFolderFiles(folderId: string): Promise<any[]>;
     createFolder({ folderName, parentFolderId }: {
         folderName: string;
         parentFolderId: string;
     }): Promise<any>;
-    getMediaFolderId(): Promise<any>;
+    /**
+     * Get the ID of the MEDIAs folder (public wrapper for getOrCreateMediaFolder)
+     * @returns The folder ID for the MEDIAs folder
+     */
+    getMediaFolderId(): Promise<string>;
     uploadBinaryFile({ file }: {
         file: File;
     }): Promise<any>;
-    saveFile({ data, folderId }: {
+    saveFile({ data, folderId, fileId }: {
         data: any;
-        folderId: string;
+        folderId?: string;
+        fileId?: string;
     }): Promise<any>;
-    /**
-     * Get file from google drive by id
-     * @param id
-     * @returns file content
-     */
     retrieve(id: string): Promise<{
         data: any;
         id: string;
     } | null>;
-    /**
-     * Get folder by folderId, if folderId == null you will have them all
-     * @param folderId [Optional]
-     * @returns
-     */
     findFolders(folderId?: string): Promise<any[]>;
-    /**
-     * Get all files content for the specified type ('KEYPAIRs' | 'VCs' | 'SESSIONs' | 'DIDs' | 'RECOMMENDATIONs')
-     * @param type
-     * @returns
-     */
     getAllFilesByType(type: FileType): Promise<any[]>;
+    updateFileData(fileId: string, data: {
+        fileName: string;
+    }): Promise<any>;
     /**
-     * Update the name of a file in Google Drive
+     * Update the content of an existing file in Google Drive
      * @param fileId - The ID of the file to update
-     * @param newFileName - The new name for the file
-     * @returns The updated file metadata, including the new name
+     * @param data - The new content for the file
+     * @returns The updated file metadata
      */
-    updateFileName(fileId: string, newFileName: string): Promise<any>;
-    findFileByName(name: string): Promise<any>;
-    findFilesUnderFolder(folderId: string): Promise<any[]>;
-    updateFileData(fileId: string, data: {
-        fileName: string;
+    updateFileContent({ fileId, data }: {
+        fileId: string;
+        data: any;
     }): Promise<any>;
     getFileParents(fileId: string): Promise<any>;
     updateRelationsFile({ relationsFileId, recommendationFileId }: {
@@ -76,25 +70,7 @@ export declare class GoogleDriveStorage {
     createRelationsFile({ vcFolderId }: {
         vcFolderId: string;
     }): Promise<any>;
-    updateResumeRelation({ authorFolderId, draftFileId, signedFileId, }: {
-        authorFolderId: string;
-        draftFileId: string;
-        signedFileId: string;
-    }): Promise<any>;
-    /**
-     * Delete file by id
-     * @param id
-     * @returns
-     */
     delete(id: string): Promise<any>;
-    update(fileId: string, data: any): Promise<any>;
-    getFileIdsFromAppDataFolder(): Promise<any>;
-    getAllFilesData(): Promise<any>;
-    /**
-     * Check if an email VC exists and return its content
-     * @param email - The email address to check
-     * @returns {Promise<{data: any, id: string} | null>} - The email VC content and ID if exists, null otherwise
-     */
     checkEmailExists(email: string): Promise<{
         data: any;
         id: string;

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

@@ -1,4 +1,4 @@
-import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+import { GoogleDriveStorage } from './GoogleDriveStorage';
 export declare const resumeFolderTypes: {
     root: string;
     nonSigned: string;
@@ -14,9 +14,10 @@ export declare class StorageHandler {
 }
 export declare class Resume extends StorageHandler {
     constructor(storage: GoogleDriveStorage);
-    saveResume({ resume, type }: {
+    saveResume({ resume, type, id }: {
         resume: any;
         type: 'sign' | 'unsigned';
+        id?: string;
     }): Promise<any>;
     find(): Promise<{
         signed: any[];

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

@@ -0,0 +1,16 @@
+import { GoogleDriveStorage } from './GoogleDriveStorage.js';
+import { WASZcapStorage } from './WASZcapStorage.js';
+export type StorageKind = 'googleDrive' | 'was' | 'wasZcap';
+export type GoogleDriveOptions = {
+    accessToken: string;
+};
+export type WASOptions = {
+    signer: any;
+    spaceId: string;
+};
+export type WASZcapOptions = {
+    appInstance: any;
+    capability: any;
+};
+export declare function createStorage(kind: 'googleDrive', options: GoogleDriveOptions): GoogleDriveStorage;
+export declare function createStorage(kind: 'wasZcap', options: WASZcapOptions): WASZcapStorage;

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

@@ -0,0 +1,30 @@
+export declare class LCWStorage {
+    private static storageClient;
+    private signer;
+    private zcap;
+    private spaceId;
+    constructor({ signer, zcap, spaceId }: {
+        signer: any;
+        zcap: any;
+        spaceId: string;
+    });
+    private getStorageClient;
+    private getResource;
+    add(key: string, value: any): Promise<{
+        ok: boolean;
+        headers: [string, string][];
+        status: number;
+        blob(): Promise<import("buffer").Blob>;
+        json(): Promise<unknown>;
+    }>;
+    read(key: string): Promise<unknown>;
+    update(key: string, value: any): Promise<{
+        ok: boolean;
+        headers: [string, string][];
+        status: number;
+        blob(): Promise<import("buffer").Blob>;
+        json(): Promise<unknown>;
+    }>;
+    delete(key: string): Promise<boolean>;
+    list(): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+export interface WasZcapStorageConfig {
+    appInstance: {
+        publicKeyMultibase: string;
+        privateKeyMultibase: string;
+        controller: string;
+        id: string;
+    };
+    capability: {
+        '@context': string[];
+        allowedAction: string[];
+        controller: string;
+        expires: string;
+        id: string;
+        invocationTarget: string;
+        parentCapability: string;
+        proof: {
+            capabilityChain: string[];
+            type: string;
+            created: string;
+            proofPurpose: string;
+            proofValue: string;
+            verificationMethod: string;
+        };
+    };
+}
+export declare class WASZcapStorage {
+    private zcapClient;
+    private capability;
+    private ready;
+    constructor(config: WasZcapStorageConfig);
+    private initClient;
+    private request;
+    private buildUrlForKey;
+    upload({ key, file }: {
+        key: string;
+        file: File | Blob;
+    }): Promise<string>;
+    read(key: string): Promise<any | null>;
+    delete(key: string): Promise<boolean>;
+    private extractId;
+}

package/dist/types/scripts/test-was.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import { Ed25519Signer } from '@did.coop/did-key-ed25519';
+/**
+ * Create a new WAS space
+ * @returns {Promise<{ signer: InstanceType<typeof Ed25519Signer>; spaceId: `urn:uuid:${string}` }>}
+ */
+export declare function createSpace(): Promise<{
+    signer: InstanceType<typeof Ed25519Signer>;
+    spaceId: `urn:uuid:${string}`;
+}>;

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

@@ -1,4 +1,4 @@
-import { KeyPair, DidDocument, FormDataI, RecommendationCredential, Credential, RecommendationFormDataI, VerifiableCredential, EmploymentFormDataI, VolunteeringFormDataI, PerformanceReviewFormDataI } from '../../types/credential';
+import { KeyPair, DidDocument, FormDataI, RecommendationCredential, Credential, RecommendationFormDataI, VerifiableCredential, EmploymentFormDataI, VolunteeringFormDataI, PerformanceReviewFormDataI } from '../../types';
 /**
  * Create a DID document using the provided key pair.
  * @param {KeyPair} keyPair - The key pair used to create the DID document.

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

@@ -0,0 +1,11 @@
+import { Ed25519VerificationKey2020 } from '@digitalbazaar/ed25519-verification-key-2020';
+export interface AppInstanceKeyPair {
+    controller: string;
+    id: string;
+    publicKeyMultibase: string;
+    privateKeyMultibase: string;
+}
+export declare function getOrCreateAppInstanceDid(): Promise<{
+    did: string;
+    keyPair: Ed25519VerificationKey2020;
+}>;

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

@@ -1,4 +1,4 @@
-import { GoogleDriveStorage } from '../models/GoogleDriveStorage.js';
+import { GoogleDriveStorage } from '../models/GoogleDriveStorage';
 export type FileType = 'VC' | 'DID' | 'SESSION' | 'RECOMMENDATION' | 'KEYPAIR';
 interface SaveToGooglePropsI {
     storage: GoogleDriveStorage;

package/dist/utils/createWASSpace.js

@@ -0,0 +1,27 @@
+import { StorageClient } from '@wallet.storage/fetch-client';
+import { Ed25519Signer } from '@did.coop/did-key-ed25519';
+import { v4 as uuidv4 } from 'uuid';
+import { WAS_BASE_URL } from '../../app.config.js';
+/**
+ * Create a new WAS space
+ * @returns {Promise<{ signer: InstanceType<typeof Ed25519Signer>; spaceId: `urn:uuid:${string}` }>}
+ */
+export async function createSpace() {
+    const signer = await Ed25519Signer.generate();
+    const controller = signer.id.split('#')[0];
+    const spaceUUID = uuidv4();
+    const spaceId = `urn:uuid:${spaceUUID}`;
+    const client = new StorageClient(new URL(WAS_BASE_URL));
+    const space = client.space({ signer, id: spaceId });
+    const spaceObject = {
+        id: spaceId,
+        controller,
+    };
+    const blob = new Blob([JSON.stringify(spaceObject)], { type: 'application/json' });
+    const res = await space.put(blob, { signer });
+    if (!res.ok) {
+        throw new Error(`Failed to initialize WAS space. Status: ${res.status}`);
+    }
+    console.log('✅ Provisioned and saved new WAS space');
+    return { signer, spaceId };
+}

package/dist/utils/credential.js

@@ -177,10 +177,7 @@ export function generateUnsignedRecommendation({ vcId, recommendation, issuerDid
 export function generateUnsignedEmployment({ formData, issuerDid }) {
     const issuanceDate = new Date().toISOString();
     const unsignedCredential = {
-        '@context': [
-            'https://www.w3.org/2018/credentials/v1',
-            employmentCredentialContext['@context'],
-        ],
+        '@context': ['https://www.w3.org/2018/credentials/v1', employmentCredentialContext['@context']],
         id: '',
         type: ['VerifiableCredential', 'EmploymentCredential'],
         issuer: { id: issuerDid, type: ['Profile'] },
@@ -192,7 +189,7 @@ export function generateUnsignedEmployment({ formData, issuerDid }) {
             credentialName: formData.credentialName,
             credentialDuration: formData.credentialDuration,
             credentialDescription: formData.credentialDescription,
-            portfolio: formData.portfolio.map(item => ({ name: item.name, url: item.url })),
+            portfolio: formData.portfolio.map((item) => ({ name: item.name, url: item.url })),
             evidenceLink: formData.evidenceLink,
             evidenceDescription: formData.evidenceDescription,
             company: formData.company,
@@ -208,10 +205,7 @@ export function generateUnsignedEmployment({ formData, issuerDid }) {
 export function generateUnsignedVolunteering({ formData, issuerDid }) {
     const issuanceDate = new Date().toISOString();
     const unsignedCredential = {
-        '@context': [
-            'https://www.w3.org/2018/credentials/v1',
-            volunteeringCredentialContext['@context'],
-        ],
+        '@context': ['https://www.w3.org/2018/credentials/v1', volunteeringCredentialContext['@context']],
         id: '',
         type: ['VerifiableCredential', 'VolunteeringCredential'],
         issuer: { id: issuerDid, type: ['Profile'] },
@@ -223,10 +217,10 @@ export function generateUnsignedVolunteering({ formData, issuerDid }) {
             volunteerWork: formData.volunteerWork,
             volunteerOrg: formData.volunteerOrg,
             volunteerDescription: formData.volunteerDescription,
-            skillsGained: formData.skillsGained ? formData.skillsGained.split(',').map(s => s.trim()) : undefined,
+            skillsGained: formData.skillsGained ? formData.skillsGained.split(',').map((s) => s.trim()) : undefined,
             duration: formData.duration,
             volunteerDates: formData.volunteerDates,
-            portfolio: formData.portfolio.map(item => ({ name: item.name, url: item.url })),
+            portfolio: formData.portfolio.map((item) => ({ name: item.name, url: item.url })),
             evidenceLink: formData.evidenceLink,
             evidenceDescription: formData.evidenceDescription,
         },
@@ -240,10 +234,7 @@ export function generateUnsignedVolunteering({ formData, issuerDid }) {
 export function generateUnsignedPerformanceReview({ formData, issuerDid }) {
     const issuanceDate = new Date().toISOString();
     const unsignedCredential = {
-        '@context': [
-            'https://www.w3.org/2018/credentials/v1',
-            performanceReviewCredentialContext['@context'],
-        ],
+        '@context': ['https://www.w3.org/2018/credentials/v1', performanceReviewCredentialContext['@context']],
         id: '',
         type: ['VerifiableCredential', 'PerformanceReviewCredential'],
         issuer: { id: issuerDid, type: ['Profile'] },
@@ -266,7 +257,7 @@ export function generateUnsignedPerformanceReview({ formData, issuerDid }) {
             overallRating: formData.overallRating,
             reviewComments: formData.reviewComments,
             goalsNext: formData.goalsNext,
-            portfolio: formData.portfolio.map(item => ({ name: item.name, url: item.url })),
+            portfolio: formData.portfolio.map((item) => ({ name: item.name, url: item.url })),
             evidenceLink: formData.evidenceLink,
             evidenceDescription: formData.evidenceDescription,
         },