@cooperation/vc-storage 1.0.40 → 1.0.41

package/README.md

@@ -1,109 +1,80 @@
 # @cooperation/vc-storage
 
-**Version**: 1.0.35
+TypeScript utilities to work with storage backends used by Linked Claims: Google Drive and Wallet Aggregated Storage (WAS). Includes a simple factory to construct storage clients and helpers used by the authoring app.
 
-## Overview
+## Installation
 
-`@cooperation/vc-storage` is a TypeScript library that allows you to sign and store Verifiable Credentials (VCs) in various storage strategies. This library provides flexibility and security by allowing you to choose where your VCs are stored, whether on cloud services like Google Drive, on your local device, or in your digital wallet. Support for Dropbox and wallet storage is currently under development.
+```bash
+npm install @cooperation/vc-storage
+```
 
-## Features
+## Exports (selected)
 
-- **Sign and Store VCs**: Securely sign your Verifiable Credentials and store them in your preferred storage medium.
-- **Google Drive Integration**: Seamlessly store your VCs on Google Drive.
-- **Local Device Storage**: Store your VCs directly on your device.
-- **Future Integrations**:
-  - **Wallet Storage**: Integration for storing VCs directly in your digital wallet (under development).
-  - **Dropbox Storage**: Integration for storing VCs in Dropbox (under development).
+- GoogleDriveStorage
+- LCWStorage (WAS via @wallet.storage/fetch-client)
+- WASZcapStorage (WAS via zCap delegation)
+- createStorage(kind, options)
+- Misc models: CredentialEngine, Resume, ResumeVC, utils
 
-## Installation
+## Storage factory
 
-You can install this package via npm:
+```ts
+import { createStorage } from '@cooperation/vc-storage';
 
-```bash
-npm install @cooperation/vc-storage
+// Google Drive
+const drive = createStorage('googleDrive', { accessToken });
+
+// WAS (zCap-capability, delegated access)
+const wasZ = createStorage('wasZcap', { appInstance, capability });
 ```
 
-## Usage
-
-### Basic Example
-
-Here’s how you can use the `@cooperation/vc-storage` library to sign and store your VCs:
-
-```typescript
-import { saveToGoogleDrive, CredentialEngine, GoogleDriveStorage } from '@cooperation/vc-storage';
-
-const accessToken = 'your-google-drive-access-token';
-const credentialEngine = new CredentialEngine();
-const storage = new GoogleDriveStorage(accessToken);
-
-async function main(useWallet = false, walletAddress = '') {
-	const formData = {
-		expirationDate: '2025-12-31T23:59:59Z',
-		fullName: 'John Doe',
-		duration: '1 year',
-		criteriaNarrative: 'This is a narrative',
-		achievementDescription: 'This is an achievement',
-		achievementName: 'Achievement Name',
-		portfolio: [
-			{ name: 'Portfolio 1', url: 'https://example.com/portfolio1' },
-			{ name: 'Portfolio 2', url: 'https://example.com/portfolio2' },
-		],
-		evidenceLink: 'https://example.com/evidence',
-		evidenceDescription: 'This is an evidence description',
-		credentialType: 'Credential Type',
-	};
-
-	let didDocument, keyPair;
-
-	// Step 1: Create DID based on the selected method
-	if (useWallet && walletAddress) {
-		({ didDocument, keyPair } = await credentialEngine.createWalletDID(walletAddress));
-	} else {
-		({ didDocument, keyPair } = await credentialEngine.createDID());
-	}
-
-	await saveToGoogleDrive(storage, { ...didDocument, keyPair }, 'DID');
-
-	const issuerDid = didDocument.id;
-
-	// Step 2: Create an Unsigned VC
-	const unsignedVC = await credentialEngine.createUnsignedVC(formData, issuerDid);
-	await saveToGoogleDrive(storage, unsignedVC, 'UnsignedVC');
-	console.log('Unsigned VC:', unsignedVC);
-
-	// Step 3: Sign the VC
-	try {
-		const signedVC = await credentialEngine.signVC(unsignedVC, keyPair);
-		await saveToGoogleDrive(storage, signedVC, 'VC');
-		console.log('Signed VC:', signedVC);
-	} catch (error) {
-		console.error('Error during VC signing:', error);
-	}
-
-	// Retrieve all stored claims
-	const claims = await storage.getAllClaims();
-	console.log('Stored Claims:', claims);
-}
-
-// Example usage:
-// 1. For Google Drive storage with standard DID creation
-main().catch(console.error);
-
-// 2. For Google Drive storage with wallet-based DID creation
-// main(true, 'your-wallet-address').catch(console.error);
+## GoogleDriveStorage (highlights)
+
+```ts
+import { GoogleDriveStorage } from '@cooperation/vc-storage';
+
+const drive = new GoogleDriveStorage(accessToken);
+
+// Upload binary (images/videos/pdfs)
+await drive.uploadBinaryFile({ file }); // -> { id }
+
+// Save JSON file to a specific folder
+await drive.saveFile({ data: { fileName: 'VC', mimeType: 'application/json', body: JSON.stringify(vc) }, folderId });
+
+// Retrieve file content
+await drive.retrieve(fileId); // -> { id, data }
+
+// Delete
+await drive.delete(fileId);
+```
+
+## WASZcapStorage (WAS, zCap delegation)
+
+Use when uploading from the browser with delegated capability (zCap).
+
+```ts
+import { WASZcapStorage } from '@cooperation/vc-storage';
+
+const was = new WASZcapStorage({ appInstance, capability });
+
+// Blob upload (images, pdfs, or JSON-as-blob)
+await was.upload({ key: file.name, file }); // -> id or url
+
+// Optional read/delete
+await was.read('key.json');
+await was.delete('old-file.txt');
 ```
 
-### Available Storage Strategies
+## Choosing a backend
 
-1. **Google Drive**: Store your VCs on Google Drive.
-2. **Local Device**: Store your VCs on your local device.
-3. **Wallet Storage**: (Under Development) Store your VCs directly in your digital wallet.
-4. **Dropbox**: (Under Development) Store your VCs in Dropbox.
+- Use WASZcapStorage when you have a zCap capability and an appInstance Ed25519 keypair (delegated, least-privilege).
+- Use GoogleDriveStorage for Drive workflows (e.g., storing VC artifacts/files in Drive).
 
-## Contributing
+## Notes
 
-Contributions are welcome! Please feel free to submit a Pull Request or open an Issue for any bugs or feature requests.
+- WAS zCap requests are signed with Ed25519Signature2020 and require a valid `invocationSigner.id`.
+- There is no implicit fallback between backends; handle errors per backend explicitly in your app.
 
 ## License
 
-This project is licensed under the ISC License.
+ISC

package/dist/index.js

@@ -4,5 +4,7 @@ export * from './utils/google.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/models/CredentialEngine.js

@@ -143,7 +143,11 @@ export class CredentialEngine {
             case 'RECOMMENDATION':
                 if (!vcFileId)
                     throw new Error('vcFileId is required for recommendation');
-                credential = generateUnsignedRecommendation({ vcId: vcFileId, recommendation: data, issuerDid: issuerId });
+                credential = generateUnsignedRecommendation({
+                    vcId: vcFileId,
+                    recommendation: data,
+                    issuerDid: issuerId,
+                });
                 break;
             case 'EMPLOYMENT':
                 credential = generateUnsignedEmployment({ formData: data, issuerDid: issuerId });

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/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/types/index.d.ts

@@ -4,5 +4,7 @@ export * from './utils/google.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/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/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/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cooperation/vc-storage",
 	"type": "module",
-	"version": "1.0.40",
+	"version": "1.0.41",
 	"description": "Sign and store your verifiable credentials.",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -23,6 +23,9 @@
 		"@digitalbazaar/ed25519-verification-key-2020": "^4.1.0",
 		"@digitalbazaar/vc": "^6.3.0",
 		"@wallet.storage/fetch-client": "^1.2.0",
+		"@digitalcredentials/ezcap": "^7.1.0",
+		"@digitalcredentials/ed25519-verification-key-2020": "^5.0.0-beta.2",
+		"@digitalcredentials/ed25519-signature-2020": "^5.0.0",
 		"add": "^2.0.6",
 		"bnid": "^3.0.0",
 		"crypto-js": "^4.2.0",