kernel-rpc-client/src/index.ts

125 lines
2.8 KiB
TypeScript
Raw Normal View History

2022-07-20 07:35:58 +00:00
import { ErrTuple } from "libskynet";
import type {
RPCRequest,
RPCResponse,
ClientRPCRequest,
} from "@lumeweb/interface-relay";
import { RpcQueryOptions } from "@lumeweb/rpc-client";
import { Buffer } from "buffer";
2023-03-23 17:02:29 +00:00
import { Client, factory } from "@lumeweb/libkernel-universal";
2022-07-20 07:35:58 +00:00
2023-03-23 16:45:19 +00:00
const RPC_MODULE = "fAAgZfXMqN3YOn0-b9DICt8OPsOFeWw3YKY2p84aytzBww";
2022-07-20 07:35:58 +00:00
export class RpcNetwork extends Client {
2022-08-31 18:42:26 +00:00
private _def: boolean;
constructor(def: boolean = true) {
super();
2022-08-31 18:42:26 +00:00
this._def = def;
}
private _networkId: number = 0;
get networkId(): number {
return this._networkId;
}
2022-07-20 07:35:58 +00:00
get ready(): Promise<ErrTuple> {
2022-08-31 18:42:26 +00:00
if (this._def) {
2022-08-31 19:25:18 +00:00
this._networkId = 1;
2022-08-31 18:42:26 +00:00
} else {
Promise.resolve()
.then(() => this.callModuleReturn(RPC_MODULE, "createNetwork"))
2022-08-31 18:42:26 +00:00
.then((ret: ErrTuple) => (this._networkId = ret[0]));
}
return this.callModuleReturn("ready", {
network: this._networkId,
});
}
public simpleQuery(
relay: Buffer | string,
query: ClientRPCRequest,
data: object | any[] = {},
options: RpcQueryOptions = {}
): SimpleRpcQuery {
return new SimpleRpcQuery({
network: this,
relay,
query,
options,
}).run();
2022-07-20 07:35:58 +00:00
}
}
export abstract class RpcQueryBase extends Client {
protected _promise?: Promise<any>;
protected _network: RpcNetwork;
protected _query: RPCRequest;
protected _options: RpcQueryOptions;
protected _queryType: string;
constructor(
network: RpcNetwork,
query: RPCRequest,
options: RpcQueryOptions = {},
queryType: string
) {
super();
this._network = network;
this._query = query;
this._options = options;
this._queryType = queryType;
}
2022-07-20 07:35:58 +00:00
2022-08-31 18:42:26 +00:00
get result(): Promise<RPCResponse> {
return (this._promise as Promise<any>)
.then((result: ErrTuple): RPCResponse => {
return result[0];
})
.catch((error: Error) => {
return { error: error.message };
});
2022-08-31 18:42:26 +00:00
}
public run(): this {
this._promise = this.callModule(this._queryType, {
query: this._query,
options: this._options,
network: this._network.networkId,
});
return this;
2022-07-20 07:35:58 +00:00
}
}
export class SimpleRpcQuery extends RpcQueryBase {
2022-08-31 23:23:38 +00:00
protected _relay: string | Buffer;
constructor({
network,
relay,
query,
options,
}: {
network: RpcNetwork;
relay: string | Buffer;
query: RPCRequest;
options: RpcQueryOptions;
}) {
super(network, query, options, "simpleQuery");
2022-08-31 21:32:52 +00:00
this._relay = relay;
}
public run(): this {
this._promise = this.callModule(this._queryType, {
relay: this._relay,
query: this._query,
options: this._options,
network: this._network.networkId,
});
return this;
}
}
2023-03-23 17:02:29 +00:00
export const createClient = factory<RpcNetwork>(RpcNetwork, RPC_MODULE);