@web5/agent
Version:
239 lines • 12 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
import { Level } from 'level';
import { LevelStore, MemoryStore } from '@web5/common';
import { DataStoreLevel, EventEmitterStream, EventLogLevel, MessageStoreLevel, ResumableTaskStoreLevel } from '@tbd54566975/dwn-sdk-js';
import { DidDht, DidJwk } from '@web5/dids';
import { AgentDidApi } from './did-api.js';
import { AgentDidResolverCache } from './agent-did-resolver-cache.js';
import { AgentDwnApi } from './dwn-api.js';
import { AgentSyncApi } from './sync-api.js';
import { Web5RpcClient } from './rpc-client.js';
import { AgentCryptoApi } from './crypto-api.js';
import { AgentIdentityApi } from './identity-api.js';
import { HdIdentityVault } from './hd-identity-vault.js';
import { LocalKeyManager } from './local-key-manager.js';
import { SyncEngineLevel } from './sync-engine-level.js';
import { DwnDidStore, InMemoryDidStore } from './store-did.js';
import { DwnKeyStore, InMemoryKeyStore } from './store-key.js';
import { DwnIdentityStore, InMemoryIdentityStore } from './store-identity.js';
import { DidResolverCacheMemory } from './prototyping/dids/resolver-cache-memory.js';
import { AgentPermissionsApi } from './permissions-api.js';
export class PlatformAgentTestHarness {
constructor(params) {
this.agent = params.agent;
this.agentStores = params.agentStores;
this.didResolverCache = params.didResolverCache;
this.dwn = params.dwn;
this.dwnDataStore = params.dwnDataStore;
this.dwnEventLog = params.dwnEventLog;
this.dwnMessageStore = params.dwnMessageStore;
this.syncStore = params.syncStore;
this.vaultStore = params.vaultStore;
this.dwnResumableTaskStore = params.dwnResumableTaskStore;
this.dwnStores = params.dwnStores;
}
clearStorage() {
return __awaiter(this, void 0, void 0, function* () {
// first stop any ongoing sync operations
yield this.agent.sync.stopSync();
// @ts-expect-error since normally this property shouldn't be set to undefined.
this.agent.agentDid = undefined;
yield this.didResolverCache.clear();
yield this.dwnDataStore.clear();
yield this.dwnEventLog.clear();
yield this.dwnMessageStore.clear();
yield this.dwnResumableTaskStore.clear();
yield this.syncStore.clear();
yield this.vaultStore.clear();
yield this.agent.permissions.clear();
this.dwnStores.clear();
// Reset the indexes and caches for the Agent's DWN data stores.
// if (this.agentStores === 'dwn') {
// const { didApi, identityApi } = PlatformAgentTestHarness.useDiskStores({ testDataLocation: '__TESTDATA__', agent: this.agent });
// this.agent.crypto = cryptoApi;
// this.agent.did = didApi;
// this.agent.identity = identityApi;
// }
// Easiest way to start with fresh in-memory stores is to re-instantiate Agent components.
if (this.agentStores === 'memory') {
const { didApi, identityApi, permissionsApi, keyManager } = PlatformAgentTestHarness.useMemoryStores({ agent: this.agent });
this.agent.did = didApi;
this.agent.identity = identityApi;
this.agent.keyManager = keyManager;
this.agent.permissions = permissionsApi;
}
});
}
closeStorage() {
return __awaiter(this, void 0, void 0, function* () {
yield this.didResolverCache.close();
yield this.dwnDataStore.close();
yield this.dwnEventLog.close();
yield this.dwnMessageStore.close();
yield this.dwnResumableTaskStore.close();
yield this.syncStore.close();
yield this.vaultStore.close();
});
}
createAgentDid() {
return __awaiter(this, void 0, void 0, function* () {
// Create a DID for the Agent.
this.agent.agentDid = yield DidJwk.create({
options: { algorithm: 'Ed25519' }
});
});
}
createIdentity({ name, testDwnUrls }) {
return __awaiter(this, void 0, void 0, function* () {
const bearerIdentity = yield this.agent.identity.create({
didMethod: 'dht',
didOptions: {
services: [
{
id: 'dwn',
type: 'DecentralizedWebNode',
serviceEndpoint: testDwnUrls,
enc: '#enc',
sig: '#sig',
}
],
verificationMethods: [
{
algorithm: 'Ed25519',
id: 'sig',
purposes: ['assertionMethod', 'authentication']
},
{
algorithm: 'secp256k1',
id: 'enc',
purposes: ['keyAgreement']
}
]
},
metadata: { name }
});
return bearerIdentity;
});
}
static setup({ agentClass, agentStores, testDataLocation }) {
return __awaiter(this, void 0, void 0, function* () {
agentStores !== null && agentStores !== void 0 ? agentStores : (agentStores = 'memory');
testDataLocation !== null && testDataLocation !== void 0 ? testDataLocation : (testDataLocation = '__TESTDATA__');
const testDataPath = (path) => `${testDataLocation}/${path}`;
// Instantiate Agent's Crypto API.
const cryptoApi = new AgentCryptoApi();
// Instantiate Agent's RPC Client.
const rpcClient = new Web5RpcClient();
const dwnStores = {
keyStore: new DwnKeyStore(),
identityStore: new DwnIdentityStore(),
didStore: new DwnDidStore(),
clear: () => {
var _a, _b, _c;
(_a = dwnStores.keyStore['_protocolInitializedCache']) === null || _a === void 0 ? void 0 : _a.clear();
(_b = dwnStores.identityStore['_protocolInitializedCache']) === null || _b === void 0 ? void 0 : _b.clear();
(_c = dwnStores.didStore['_protocolInitializedCache']) === null || _c === void 0 ? void 0 : _c.clear();
}
};
const { agentVault, didApi, identityApi, keyManager, didResolverCache, vaultStore, permissionsApi } = (agentStores === 'memory')
? PlatformAgentTestHarness.useMemoryStores()
: PlatformAgentTestHarness.useDiskStores({ testDataLocation, stores: dwnStores });
// Instantiate custom stores to use with DWN instance.
// Note: There is no in-memory store for DWN, so we always use LevelDB-based disk stores.
const dwnDataStore = new DataStoreLevel({ blockstoreLocation: testDataPath('DWN_DATASTORE') });
const dwnEventLog = new EventLogLevel({ location: testDataPath('DWN_EVENTLOG') });
const dwnEventStream = new EventEmitterStream();
const dwnResumableTaskStore = new ResumableTaskStoreLevel({ location: testDataPath('DWN_RESUMABLETASKSTORE') });
const dwnMessageStore = new MessageStoreLevel({
blockstoreLocation: testDataPath('DWN_MESSAGESTORE'),
indexLocation: testDataPath('DWN_MESSAGEINDEX')
});
// Instantiate DWN instance using the custom stores.
const dwn = yield AgentDwnApi.createDwn({
dataPath: testDataLocation,
dataStore: dwnDataStore,
didResolver: didApi,
eventLog: dwnEventLog,
eventStream: dwnEventStream,
messageStore: dwnMessageStore,
resumableTaskStore: dwnResumableTaskStore
});
// Instantiate Agent's DWN API using the custom DWN instance.
const dwnApi = new AgentDwnApi({ dwn });
// Instantiate Agent's Sync API using a custom LevelDB-backed store.
const syncStore = new Level(testDataPath('SYNC_STORE'));
const syncEngine = new SyncEngineLevel({ db: syncStore });
const syncApi = new AgentSyncApi({ syncEngine });
// Create Web5PlatformAgent instance
const agent = new agentClass({
agentVault,
cryptoApi,
didApi,
dwnApi,
identityApi,
keyManager,
permissionsApi,
rpcClient,
syncApi,
});
return new PlatformAgentTestHarness({
agent,
agentStores,
didResolverCache,
dwn,
dwnDataStore,
dwnEventLog,
dwnMessageStore,
dwnResumableTaskStore,
dwnStores,
syncStore,
vaultStore
});
});
}
static useDiskStores({ agent, testDataLocation, stores }) {
const testDataPath = (path) => `${testDataLocation}/${path}`;
const vaultStore = new LevelStore({ location: testDataPath('VAULT_STORE') });
const agentVault = new HdIdentityVault({ keyDerivationWorkFactor: 1, store: vaultStore });
const { didStore, identityStore, keyStore } = stores;
// Setup DID Resolver Cache
const didResolverCache = new AgentDidResolverCache({
location: testDataPath('DID_RESOLVERCACHE')
});
const didApi = new AgentDidApi({
agent: agent,
didMethods: [DidDht, DidJwk],
resolverCache: didResolverCache,
store: didStore
});
const identityApi = new AgentIdentityApi({ agent, store: identityStore });
const keyManager = new LocalKeyManager({ agent, keyStore: keyStore });
const permissionsApi = new AgentPermissionsApi({ agent });
return { agentVault, didApi, didResolverCache, identityApi, keyManager, permissionsApi, vaultStore };
}
static useMemoryStores({ agent } = {}) {
const vaultStore = new MemoryStore();
const agentVault = new HdIdentityVault({ keyDerivationWorkFactor: 1, store: vaultStore });
// Setup DID Resolver Cache
const didResolverCache = new DidResolverCacheMemory();
const didApi = new AgentDidApi({
agent: agent,
didMethods: [DidDht, DidJwk],
resolverCache: didResolverCache,
store: new InMemoryDidStore()
});
const keyManager = new LocalKeyManager({ agent, keyStore: new InMemoryKeyStore() });
const identityApi = new AgentIdentityApi({ agent, store: new InMemoryIdentityStore() });
const permissionsApi = new AgentPermissionsApi({ agent });
return { agentVault, didApi, didResolverCache, identityApi, keyManager, permissionsApi, vaultStore };
}
}
//# sourceMappingURL=test-harness.js.map