The plugin of client for help work with JSON-ROC over nestjs-json-rpc Work with RPC look like call function
npm install @klerick/nestjs-json-rpc-sdkOnce the installation process is complete, we can import the RpcFactory. For example, we have RPC server which have service which implement this interface:
export type InputType = {
a: number;
b: number;
};
export type OutputType = {
c: string;
d: string;
};
export interface RpcService {
someMethod(firstArg: number): Promise<number>;
someOtherMethod(firstArg: number, secondArgument: number): Promise<string>;
methodWithObjectParams(a: InputType): Promise<OutputType>;
}import {
RpcFactory,
} from '@klerick/nestjs-json-rpc-sdk';
const { rpc, rpcBatch } = RpcFactory(
{
rpcHost: `http://localhost:${port}`,
rpcPath: `/api/rpc`,
transport: TransportType.HTTP,
},
false
);
rpc.RpcService.someMethod(1).sibcribe(r => console.log(r))
const call1 = rpcForBatch.RpcService.someMethod(1);
const call2 = rpcForBatch.RpcService.methodWithObjectParams({
a: 1,
b: 2,
});
rpcBatch(call1, call2).sibcribe(([result1, result2]) => console.log(result1, result2))That's all:)
You can use typescript for type checking:
import {
RpcFactory,
} from '@klerick/nestjs-json-rpc-sdk';
type MapperRpc = {
RpcService: RpcService;
};
const { rpc, rpcBatch } = RpcFactory<MapperRpc>(
{
rpcHost: `http://localhost:${port}`,
rpcPath: `/api/rpc`,
transport: TransportType.HTTP,
},
false
);
//TS2345: Argument of type string is not assignable to parameter of type number
const call = rpc.RpcService.someMethod('inccorectParam');
//TS2339: Property IncorrectService does not exist on type MapperRpc
const call2 = rpc.IncorrectService.someMethod(1);
//TS2339: Property incorrectMethod does not exist on type RpcService
const call3 = rpc.RpcService.incorrectMethod(1);By default, HTTP transport using fetch, but you can set other:
import axios from 'axios';
import {
RpcFactory,
axiosTransportFactory,
} from '@klerick/nestjs-json-rpc-sdk';
const { rpc, rpcBatch } = RpcFactory<MapperRpc>(
{
rpcHost: `http://localhost:4200`,
rpcPath: `/api/rpc`,
transport: TransportType.HTTP,
httpAgentFactory: axiosTransportFactory(axios),
},
false
);Or you can implement your personal factory.
You should implement HttpAgentFactory type
type Transport<T extends LoopFunc> = (
body: PayloadRpc<T>
) => Observable<RpcResult<T>>;
type HttpAgentFactory<T extends LoopFunc> = (
url: string
) => Transport<T>;if you want to use Promise instead of Observer
!!!!: - you need to use another object for prepare rpc batch call
import axios from 'axios';
import {
RpcFactory,
axiosTransportFactory,
} from '@klerick/nestjs-json-rpc-sdk';
const { rpc, rpcBatch, rpcForBatch } = RpcFactory<MapperRpc>(
{
rpcHost: `http://localhost:4200`,
rpcPath: `/api/rpc`,
transport: TransportType.HTTP,
httpAgentFactory: axiosTransportFactory(axios),
},
true // need true for use promise as result
);
const result = await rpc.RpcService.someMethod(1)
const call1 = rpcForBatch.RpcService.someMethod(1);
const call2 = rpcForBatch.RpcService.methodWithObjectParams({
a: 1,
b: 2,
});
const [result1, result2] = await rpcBatch(call1, call2);For use WebSocket
import {
RpcFactory,
} from '@klerick/nestjs-json-rpc-sdk';
import { WebSocket as ws } from 'ws';
import { webSocket } from 'rxjs/webSocket';
const someUrl = 'ws://localhost:4200/rpc'
const destroySubject = new Subject<boolean>();
const nativeSocketInstance = webSocket<any>(destroySubject);
const { rpc, rpcBatch } = RpcFactory<MapperRpc>(
{
transport: TransportType.WS,
useWsNativeSocket: true, // - Will be use native WebSocket
//nativeSocketImplementation: ws, - if you use NodeJS you can use other implementation
rpcHost: `http://localhost:4200`,
rpcPath: `/rpc`,
destroySubject, // - If you need close connection you need call destroySubject.next(true),
//nativeSocketInstance - you can use your owner socket instance
},
false
);You can use socket.io
import {
RpcFactory,
} from '@klerick/nestjs-json-rpc-sdk';
import { io } from 'socket.io-client';
const someUrl = 'ws://localhost:4200'
const destroySubject = new Subject<boolean>();
const ioSocketInstance = io(someUrl, { path: '/rpc' })
const { rpc, rpcBatch } = RpcFactory<MapperRpc>(
{
transport: TransportType.WS,
useWsNativeSocket: false, // - Will be use socket.io
destroySubject, // - If you need close connection you need call destroySubject.next(true),
ioSocketInstance
},
false
);You can use Angular module:
import {
JsonRpcAngular,
JsonRpcAngularConfig,
TransportType,
} from '@klerick/nestjs-json-rpc-sdk/json-rpc-sdk.module'
import { Subject } from 'rxjs';
import { io } from 'socket.io-client';
import {
JSON_RPC,
RPC_BATCH,
Rpc,
} from '@klerick/nestjs-json-rpc-sdk/json-rpc-sdk.module';
@Component({
standalone: true,
selector: 'nestjs-json-api-root',
templateUrl: './app.component.html',
styleUrl: './app.component.css',
})
export class AppComponent {
private rpc = inject<Rpc<MapperRpc>>(JSON_RPC);
private rpcBatch = inject(RPC_BATCH);
}
const destroySubjectToken = new InjectionToken('destroySubjectToken', {
factory: () => new Subject<boolean>(),
});
const tokenSocketInst = new InjectionToken('tokenSocketInst', {
factory: () => webSocket('ws://localhost:4200/rpc'),
});
const tokenIoSocketInst = new InjectionToken('tokenIoSocketInst', {
factory: () => io('http://localhost:4200', { path: '/rpc' }),
});
const httpConfig: JsonRpcAngularConfig = {
transport: TransportType.HTTP,
rpcPath: '/api/rpc',
rpcHost: 'http://localhost:4200',
};
const wsConfig: JsonRpcAngularConfig = {
transport: TransportType.WS,
useWsNativeSocket: true,
rpcPath: 'rpc',
rpcHost: 'ws://localhost:4200',
destroySubjectToken,
};
const wsConfigWithToken: JsonRpcAngularConfig = {
transport: TransportType.WS,
useWsNativeSocket: true,
tokenSocketInst,
destroySubjectToken,
};
const ioConfig: JsonRpcAngularConfig = {
transport: TransportType.WS,
useWsNativeSocket: false,
destroySubjectToken,
tokenSocketInst: tokenIoSocketInst,
};
bootstrapApplication(AppComponent, {
providers: [
importProvidersFrom(
JsonRpcAngular.forRoot(httpConfig)
),
],
}).catch((err) =>
console.error(err)
);