Wondering what’s next for npm?Check out our public roadmap! »

    @metarhia/jstp

    2.3.0 • Public • Published
    Metarhia Logo

    Travis CI AppVeyor CI Coverage Status NPM Version NPM Downloads/Month NPM Downloads

    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 implementation bundled in!

    This project is bound by a Code of Conduct.

    Installation

    JSTP works in Node.js and web browsers:

    $ npm install --save @metarhia/jstp

    Or, alternatively, there is jstp.umd.js UMD bundle.

    We also have official client-side implementations for Swift and Java that work effortlessly on iOS and Android 🎉

    There is also an interactive CLI provided by this package:

    $ npm install -g @metarhia/jstp
    $ jstp-cli

    Getting Started

    Server:

    '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:

    '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 for the initial idea and proof-of-concept implementation. Current project team is:

    Install

    npm i @metarhia/jstp

    DownloadsWeekly Downloads

    24

    Version

    2.3.0

    License

    MIT

    Unpacked Size

    610 kB

    Total Files

    37

    Last publish

    Collaborators

    • avatar
    • avatar
    • avatar
    • avatar
    • avatar