rpc_ts/lib/examples/server_stream/index.js

Remote Procedure Calls in TypeScript made simple

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * @license
 * Copyright (c) Aiden.ai
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
const express = require("express");
const service_1 = require("./service");
const http = require("http");
const grpc_web_node_http_transport_1 = require("@improbable-eng/grpc-web-node-http-transport");
const handler_1 = require("./handler");
const client_1 = require("../../client");
const assert_1 = require("assert");
const server_1 = require("../../context/server");
const server_2 = require("../../protocol/server");
const client_2 = require("../../protocol/client");
main().catch(
/* istanbul ignore next */
err => {
    console.error(err);
    process.exit(1);
});
async function main() {
    // We launch an Express server, register the RPC routes using the
    // `grpc_web` protocol, initialize a `grpc_web` client connected to this server
    // and perform some remote procedure calls.
    const server = setupServer();
    try {
        await clientInteraction(`http://127.0.0.1:${server.address().port}/api`);
    }
    finally {
        server.close();
    }
}
function setupServer() {
    const app = express();
    app.use('/api', server_2.ModuleRpcProtocolServer.registerRpcRoutes(service_1.numberServiceDefinition, handler_1.getNumberHandler(), {
        serverContextConnector: new server_1.ModuleRpcContextServer.EmptyServerContextConnector(),
    }));
    const server = http.createServer(app).listen();
    const port = server.address().port;
    app.set('port', port);
    return server;
}
async function clientInteraction(remoteAddress) {
    const client = client_2.ModuleRpcProtocolClient.getRpcClient(service_1.numberServiceDefinition, {
        remoteAddress,
        getGrpcWebTransport: grpc_web_node_http_transport_1.NodeHttpTransport(),
    });
    // We call our unary method
    const { value } = await client.increment({ value: 10 });
    console.log('Value is', value);
    // Now we convert a server stream into a promise.  The promise resolves to
    // an array containing all the messages that were streamed before the 'complete'
    // event was emitted.
    const result = await client_1.ModuleRpcClient.streamAsPromise(streamNumbers(client));
    console.log('ping: all messages:', result);
    // Here, we cancel the call right in the middle of streaming.  An exception is thrown.
    try {
        const stream = streamNumbers(client).on('ready', () => {
            setTimeout(() => stream.cancel(), 2000);
        });
        await client_1.ModuleRpcClient.streamAsPromise(stream);
        throw new assert_1.AssertionError({ message: 'expected cancelation error' });
    }
    catch (err) {
        console.error('Expected cancelation error:', err);
    }
}
function streamNumbers(client) {
    return client
        .streamNumbers({ max: 3, sleepMs: 500 })
        .on('ready', () => {
        console.log('ping: onReady()');
    })
        .on('message', message => {
        console.log(`ping: onMessage(${JSON.stringify(message)})`);
    })
        .on('canceled', () => {
        console.log('ping: canceled');
    })
        .on('error', 
    /* istanbul ignore next */
    err => {
        console.log('ping: error (not supposed to happen):', err);
    });
}
//# sourceMappingURL=index.js.map