@uprtcl/holochain-provider
Version:
_Prtcl provider wrappers around @holochain/hc-web-client
288 lines (271 loc) • 12 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata'), require('@holochain/hc-web-client'), require('path'), require('@uprtcl/multiplatform'), require('@uprtcl/micro-orchestrator'), require('inversify')) :
typeof define === 'function' && define.amd ? define(['exports', 'reflect-metadata', '@holochain/hc-web-client', 'path', '@uprtcl/multiplatform', '@uprtcl/micro-orchestrator', 'inversify'], factory) :
(global = global || self, factory(global['uprtcl-holochain-provider'] = {}, null, global.hcWebClient, global.path, global.multiplatform, global.microOrchestrator, global.inversify));
}(this, (function (exports, reflectMetadata, hcWebClient, path, multiplatform, microOrchestrator, inversify) { 'use strict';
path = path && Object.prototype.hasOwnProperty.call(path, 'default') ? path['default'] : path;
function parseZomeResponse(jsonString) {
const result = typeof jsonString === 'string' ? JSON.parse(jsonString) : jsonString;
if (result.Err)
throw new Error(JSON.stringify(result.Err));
if (result.SerializationError) {
throw new Error(JSON.stringify(result.SerializationError));
}
return parseResponse(result);
}
function parseResponse(response) {
return response.hasOwnProperty('Ok') ? response.Ok : response;
}
function parseEntry(entry) {
return JSON.parse(parseResponse(entry).App[1]);
}
function parseEntryResult(entry) {
entry = parseResponse(entry);
if (!entry.result.Single.meta)
return undefined;
return {
entry: {
id: entry.result.Single.meta.address,
object: parseEntry(entry.result.Single.entry),
},
type: entry.result.Single.meta.entry_type.App,
};
}
function parseEntries(entryArray) {
return entryArray.map((entry) => parseEntry(entry));
}
function parseEntriesResults(entryArray) {
return entryArray
.map((entry) => parseEntryResult(parseResponse(entry)))
.filter((entry) => entry != undefined);
}
class HolochainConnection extends multiplatform.SocketConnection {
constructor(hcConnectionOptions, options = {}) {
super(options);
this.hcConnectionOptions = hcConnectionOptions;
this.signalListeners = [];
}
async createSocket() {
const { call, callZome, ws, onSignal } = await hcWebClient.connect({ url: this.hcConnectionOptions.host });
this.genericCall = call;
this.connection = async (instance, zome, funcName, params) => callZome(instance, zome, funcName)(params);
this.onsignal = onSignal;
this.onsignal((params) => {
this.signalListeners.forEach((l) => l(params));
});
return ws;
}
async getAgentConfig(agentAddress) {
const agentList = await this.callAdmin('admin/agent/list', {});
const agentName = agentList.find((a) => a.public_address === agentAddress);
return agentName;
}
async cloneDna(agentId, newDnaId, newInstanceId, templateDnaAddress, properties, findInterface) {
const holoscapeDataDir = this.getHoloscapeDataDir();
let path = undefined;
if (holoscapeDataDir) {
path = `${holoscapeDataDir}/dna/${templateDnaAddress}.dna.json`;
}
else {
if (!this.hcConnectionOptions.devEnv)
throw new Error('Trying to clone a DNA in development environment but without the devEnv property of HolochainConnection set');
path = this.hcConnectionOptions.devEnv.templateDnasPaths[templateDnaAddress];
}
const dnaResult = await this.callAdmin('admin/dna/install_from_file', {
id: newDnaId,
path,
properties,
copy: true,
});
const instanceResult = await this.callAdmin('admin/instance/add', {
id: newInstanceId,
agent_id: agentId,
dna_id: newDnaId,
});
const interfaceList = await this.callAdmin('admin/interface/list', {});
// TODO: review this: what interface to pick?
const iface = findInterface(interfaceList);
const ifaceResult = this.callAdmin('admin/interface/add_instance', {
instance_id: newInstanceId,
interface_id: iface.id,
});
await new Promise((resolve) => setTimeout(() => resolve(), 300));
const startResult = await this.callAdmin('admin/instance/start', { id: newInstanceId });
}
/**
* Returns whether this connection is attached to an admin permissioned interface
*/
async isAdminInterface() {
try {
await this.callAdmin('admin/dna/list', {});
return true;
}
catch (e) {
return false;
}
}
/**
* Will return undefined if we are not on holoscape
*/
getHoloscapeDataDir() {
try {
const { app } = window.require('electron').remote;
const holoscapeOrStandalone = 'Holoscape-default';
const rootConfigPath = path.join(app.getPath('appData'), holoscapeOrStandalone);
return rootConfigPath;
}
catch (e) {
return undefined;
}
}
async callAdmin(funcName, params) {
this.logger.log('CALL ADMIN INTERFACE:', funcName, params);
const jsonString = await this.genericCall(funcName)(params);
const result = parseZomeResponse(jsonString);
this.logger.log('ADMIN CALL RESULT:', funcName, params, result);
return result;
}
async call(instance, zome, funcName, params) {
this.logger.log('CALL ZOME:', funcName, params);
const jsonString = await this.connection(instance, zome, funcName, params);
const result = parseZomeResponse(jsonString);
this.logger.log('ZOME RESULT:', funcName, params, result);
return result;
}
async onSignal(signalName, callback) {
await this.ready();
const listener = (params) => {
if (params.signal && params.signal.name === signalName) {
let args = params.signal.arguments;
try {
args = JSON.parse(args);
}
catch (e) { }
callback(args);
}
};
this.signalListeners.push(listener);
}
}
const HolochainConnectionBindings = {
HolochainConnection: 'holochain-connection',
};
class HolochainConnectionModule extends microOrchestrator.MicroModule {
constructor(connection) {
super();
this.connection = connection;
}
async onLoad(container) {
await this.connection.ready();
container
.bind(HolochainConnectionModule.bindings.HolochainConnection)
.toConstantValue(this.connection);
}
}
HolochainConnectionModule.id = 'holochain-connection-module';
HolochainConnectionModule.bindings = HolochainConnectionBindings;
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
exports.HolochainProvider = class HolochainProvider {
constructor(connection) {
this.connection = connection;
}
/**
* @override
*/
async ready() {
await this.connection.ready();
}
async call(funcName, params) {
return this.connection.call(this.instance, this.zome, funcName, params);
}
async isLogged() {
return true;
}
async login() { }
async logout() { }
async connect() { }
async isConnected() {
return true;
}
async disconnect() { }
};
exports.HolochainProvider = __decorate([
inversify.injectable(),
__param(0, inversify.inject(HolochainConnectionBindings.HolochainConnection)),
__metadata("design:paramtypes", [HolochainConnection])
], exports.HolochainProvider);
function createHolochainProvider(instance, zome) {
let ConcreteProvider = class ConcreteProvider extends exports.HolochainProvider {
constructor() {
super(...arguments);
this.instance = instance;
this.zome = zome;
}
};
ConcreteProvider = __decorate([
inversify.injectable()
], ConcreteProvider);
return ConcreteProvider;
}
exports.KnownSourcesHolochain = class KnownSourcesHolochain extends exports.HolochainProvider {
constructor() {
super(...arguments);
this.zome = 'discovery';
}
async getUpl() {
const response = await this.call('get_uprtcl_provider_locator', {});
return parseResponse(response);
}
getKnownSources(hash) {
return this.call('get_known_sources', { address: hash });
}
addKnownSources(hash, casIDs) {
return this.call('add_known_sources', {
address: hash,
casIDs: casIDs,
});
}
removeKnownSource(hash, casID) {
return this.call('remove_known_source', {
address: hash,
casID: casID,
});
}
};
exports.KnownSourcesHolochain = __decorate([
inversify.injectable()
], exports.KnownSourcesHolochain);
exports.HolochainConnection = HolochainConnection;
exports.HolochainConnectionModule = HolochainConnectionModule;
exports.createHolochainProvider = createHolochainProvider;
exports.parseEntries = parseEntries;
exports.parseEntriesResults = parseEntriesResults;
exports.parseEntry = parseEntry;
exports.parseEntryResult = parseEntryResult;
exports.parseResponse = parseResponse;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=uprtcl-holochain-provider.umd.js.map