kernel-rpc-client/dist/index.js

158 lines
4.8 KiB
JavaScript

const RPC_MODULE = "AQDaEPIo_lpdvz7AKbeafERBHR331RiyvweJ6OrFTplzyg";
let callModule, connectModule;
async function loadLibs() {
if (callModule && connectModule) {
return;
}
if (typeof window !== "undefined" && window?.document) {
const pkg = await import("libkernel");
callModule = pkg.callModule;
connectModule = pkg.connectModule;
}
else {
const pkg = await import("libkmodule");
callModule = pkg.callModule;
connectModule = pkg.connectModule;
}
}
export class RpcNetwork {
_actionQueue = [];
_addQueue = [];
_removeQueue = [];
_def;
constructor(def = true) {
this._def = def;
}
_networkId = 0;
get networkId() {
return this._networkId;
}
get ready() {
let promise = loadLibs();
if (this._def) {
this._networkId = 0;
}
else {
promise = promise
.then(() => callModule(RPC_MODULE, "createNetwork"))
.then((ret) => (this._networkId = ret[0]));
}
return promise.then(() => callModule(RPC_MODULE, "ready", { network: this._networkId }));
}
static deleteItem(array, item) {
if (array.includes(item)) {
let queue = new Set(array);
queue.delete(item);
[].splice.apply(array, [0, array.length].concat([...queue]));
}
}
addRelay(pubkey) {
this._addQueue.push(pubkey);
this._addQueue = [...new Set(this._addQueue)];
RpcNetwork.deleteItem(this._removeQueue, pubkey);
}
removeRelay(pubkey) {
this._removeQueue.push(pubkey);
this._removeQueue = [...new Set(this._removeQueue)];
RpcNetwork.deleteItem(this._addQueue, pubkey);
}
clearRelays() {
this._actionQueue.push(["clearRelays", {}]);
}
wisdomQuery(method, module, data = {}, bypassCache = false, options = {}) {
return new WisdomRpcQuery(this, {
method,
module,
data,
bypassCache,
}, options).run();
}
streamingQuery(relay, method, module, streamHandler, data = {}, options = {}) {
return new StreamingRpcQuery(this, relay, { method, module, data }, { streamHandler, ...options }).run();
}
simpleQuery(relay, method, module, data = {}, options = {}) {
return new SimpleRpcQuery(this, relay, {
method,
module,
data,
}, options).run();
}
async processQueue() {
await loadLibs();
for (const action of this._actionQueue) {
try {
await callModule(RPC_MODULE, action[0], {
...action[1],
network: this._networkId,
});
}
catch (e) { }
}
await Promise.allSettled(this._removeQueue.map((item) => callModule(RPC_MODULE, "removeRelay", {
pubkey: item,
network: this._networkId,
})));
await Promise.allSettled(this._addQueue.map((item) => callModule(RPC_MODULE, "addRelay", {
pubkey: item,
network: this._networkId,
})));
this._actionQueue = [];
this._removeQueue = [];
this._addQueue = [];
}
}
export class RpcQueryBase {
_promise;
_network;
_query;
_options;
_queryType;
constructor(network, query, options = {}, queryType) {
this._network = network;
this._query = query;
this._options = options;
this._queryType = queryType;
}
get result() {
return this._promise.then((result) => {
if (result[1]) {
return { error: result[1] };
}
return result[0];
});
}
run() {
this._promise = this._network.processQueue().then(() => callModule(RPC_MODULE, this._queryType, {
query: this._query,
options: this._options,
network: this._network.networkId,
}));
return this;
}
}
export class SimpleRpcQuery extends RpcQueryBase {
constructor(network, relay, query, options) {
super(network, query, options, "simpleQuery");
}
}
export class StreamingRpcQuery extends RpcQueryBase {
_options;
constructor(network, relay, query, options) {
super(network, query, options, "streamingQuery");
this._options = options;
}
run() {
this._promise = this._network.processQueue().then(() => connectModule(RPC_MODULE, this._queryType, {
query: this._query,
options: this._options,
network: this._network.networkId,
}, this._options.streamHandler));
return this;
}
}
export class WisdomRpcQuery extends RpcQueryBase {
constructor(network, query, options = {}) {
super(network, query, options, "wisdomQuery");
}
}