Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/metarhia/jstp
Fast RPC for browser and Node.js based on TCP, WebSocket, and MDSF
https://github.com/metarhia/jstp
api client highload impress ipc javascript json json5 jstp metarhia node nodejs protocol rpc serialization server soa socket tcp websocket
Last synced: about 1 month ago
JSON representation
Fast RPC for browser and Node.js based on TCP, WebSocket, and MDSF
- Host: GitHub
- URL: https://github.com/metarhia/jstp
- Owner: metarhia
- License: other
- Created: 2016-03-05T12:55:44.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2022-12-07T17:36:00.000Z (almost 2 years ago)
- Last Synced: 2024-07-14T14:22:46.739Z (about 2 months ago)
- Topics: api, client, highload, impress, ipc, javascript, json, json5, jstp, metarhia, node, nodejs, protocol, rpc, serialization, server, soa, socket, tcp, websocket
- Language: JavaScript
- Homepage: https://metarhia.github.io/jstp
- Size: 4.82 MB
- Stars: 142
- Watchers: 18
- Forks: 10
- Open Issues: 26
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
JSTP / JavaScript Transfer Protocol
JSTP is an RPC protocol and framework which provides two-way asynchronous data
transfer with support of multiple parallel non-blocking interactions that is so
transparent that an app may not even distinguish between local async functions
and remote procedures.
And, as a nice bonus, there's a blazing fast [JSON5](https://github.com/json5)
implementation bundled in!
**This project is bound by a [Code of Conduct](CODE_OF_CONDUCT.md).**
## Installation
JSTP works in Node.js and web browsers:
```sh
$ npm install --save @metarhia/jstp
```
Or, alternatively, there is
[jstp.umd.js](https://unpkg.com/@metarhia/jstp@latest/dist/jstp.umd.js)
UMD bundle.
We also have official client-side implementations for
[Swift](https://github.com/metarhia/jstp-swift) and
[Java](https://github.com/metarhia/jstp-java)
that work effortlessly on iOS and Android 🎉
There is also an interactive CLI provided by this package:
```sh
$ npm install -g @metarhia/jstp
$ jstp-cli
```
## Getting Started
Server:
```js
'use strict';
const jstp = require('@metarhia/jstp');
// Application is the core high-level abstraction of the framework. An app
// consists of a number of interfaces, and each interface has its methods.
const app = new jstp.Application('testApp', {
someService: {
sayHi(connection, name, callback) {
callback(null, `Hi, ${name}!`);
},
},
});
// Let's create a TCP server for this app. Other available transports are
// WebSocket and Unix domain sockets. One might notice that an array of
// applications is passed the `createServer()`. That's because it can serve
// any number of applications.
const server = jstp.net.createServer([app]);
server.listen(3000, () => {
console.log('TCP server listening on port 3000 🚀');
});
```
Client:
```js
'use strict';
const jstp = require('@metarhia/jstp');
// Create a TCP connection to server and connect to the `testApp` application.
// Clients can have applications too for full-duplex RPC,
// but we don't need that in this example. Client is `null` in this example,
// this implies that username and password are both `null`
// here — that is, the protocol-level authentication is not leveraged in this
// example. The next argument is an array of interfaces to inspect and build
// remote proxy objects for. Remaining arguments are for
// net.connect (host and port) and last argument is a callback
// to be called on successful connection or error.
jstp.net.connectAndInspect(
'testApp',
null,
['someService'],
3000,
'localhost',
handleConnect
);
function handleConnect(error, connection, app) {
if (error) {
console.error(`Could not connect to the server: ${error}`);
return;
}
// The `app` object contains remote proxy objects for each interface that has
// been requested which allow to use remote APIs as regular async functions.
// Remote proxies are also `EventEmitter`s: they can be used to `.emit()`
// events to another side of a connection and listen to them using `.on()`.
app.someService.sayHi('JSTP', (error, message) => {
if (error) {
console.error(`Oops, something went wrong: ${error}`);
return;
}
console.log(`Server said "${message}" 😲`);
});
}
```
## Project Maintainers
Kudos to [@tshemsedinov](https://github.com/tshemsedinov) for the initial idea
and proof-of-concept implementation. Current project team is:
- [@aqrln](https://github.com/aqrln) —
**Alexey Orlenko** <[email protected]>
- [@belochub](https://github.com/belochub) —
**Mykola Bilochub** <[email protected]>
- [@lundibundi](https://github.com/lundibundi) —
**Denys Otrishko** <[email protected]>
- [@nechaido](https://github.com/nechaido) —
**Dmytro Nechai** <[email protected]>
- [@tshemsedinov](https://github.com/tshemsedinov) —
**Timur Shemsedinov** <[email protected]>