@replit/river 0.1.5 → 0.1.6

package/README.md

@@ -1,15 +1,18 @@
 # river - Streaming Remote Procedure Calls
 
 It's like tRPC but...
+
 - with JSON Schema Support
 - with full-duplex streaming
 - with support for service multiplexing
 - over WebSockets
 
 ## Levels of abstraction
+
 - Router
 - Service
 - Procedure
 
 ## TODO
-- support broadcast
+
+- support broadcast

package/dist/__tests__/integration.test.js

@@ -3,11 +3,14 @@ import { Type } from '@sinclair/typebox';
 import { ServiceBuilder, serializeService } from '../router/builder';
 import { reply } from '../transport/message';
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
-import { createWebSocketServer, createWsTransports, onServerReady } from '../transport/ws.util';
+import { createWebSocketServer, createWsTransports, onServerReady, } from '../transport/util';
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import { asClientRpc, asClientStream } from '../router/server.util';
-export const EchoRequest = Type.Object({ msg: Type.String(), ignore: Type.Boolean() });
+export const EchoRequest = Type.Object({
+    msg: Type.String(),
+    ignore: Type.Boolean(),
+});
 export const EchoResponse = Type.Object({ response: Type.String() });
 export const TestServiceConstructor = () => ServiceBuilder.create('test')
     .initialState({
@@ -98,8 +101,12 @@ describe('server-side test', () => {
         i.push({ msg: 'def', ignore: true });
         i.push({ msg: 'ghi', ignore: false });
         i.end();
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({ response: 'abc' });
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({ response: 'ghi' });
+        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+            response: 'abc',
+        });
+        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+            response: 'ghi',
+        });
         expect(o.readableLength).toBe(0);
     });
 });
@@ -122,7 +129,9 @@ describe('client <-> server integration test', () => {
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(st, serviceDefs);
         const client = createClient(ct);
-        await expect(client.test.add({ n: 3 })).resolves.toStrictEqual({ result: 3 });
+        await expect(client.test.add({ n: 3 })).resolves.toStrictEqual({
+            result: 3,
+        });
     });
     test('stream', async () => {
         const [ct, st] = await createWsTransports(port, wss);
@@ -134,8 +143,12 @@ describe('client <-> server integration test', () => {
         i.push({ msg: 'def', ignore: true });
         i.push({ msg: 'ghi', ignore: false });
         i.end();
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({ response: 'abc' });
-        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({ response: 'ghi' });
+        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+            response: 'abc',
+        });
+        await expect(o.next().then((res) => res.value)).resolves.toStrictEqual({
+            response: 'ghi',
+        });
         close();
     });
 });

package/dist/codec/json.d.ts

@@ -1,2 +1,2 @@
-import { Codec } from "./types";
+import { Codec } from './types';
 export declare const NaiveJsonCodec: Codec;

package/dist/index.d.ts

@@ -8,6 +8,6 @@ export type { Server } from './router/server';
 export { Transport } from './transport/types';
 export { TransportMessageSchema, OpaqueTransportMessageSchema, TransportAckSchema, msg, payloadToTransportMessage, ack, reply, } from './transport/message';
 export type { TransportMessage, MessageId, OpaqueTransportMessage, TransportClientId, TransportMessageAck, } from './transport/message';
-export { StdioTransport } from './transport/stdio';
+export { StreamTransport } from './transport/stream';
 export { WebSocketTransport } from './transport/ws';
-export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, waitForSocketReady, createWebSocketClient, } from './transport/ws.util';
+export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, waitForSocketReady, createWebSocketClient, } from './transport/util';

package/dist/index.js

@@ -4,6 +4,6 @@ export { createServer } from './router/server';
 export { asClientRpc, asClientStream } from './router/server.util';
 export { Transport } from './transport/types';
 export { TransportMessageSchema, OpaqueTransportMessageSchema, TransportAckSchema, msg, payloadToTransportMessage, ack, reply, } from './transport/message';
-export { StdioTransport } from './transport/stdio';
+export { StreamTransport } from './transport/stream';
 export { WebSocketTransport } from './transport/ws';
-export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, waitForSocketReady, createWebSocketClient, } from './transport/ws.util';
+export { createWebSocketServer, onServerReady, createWsTransports, waitForMessage, waitForSocketReady, createWebSocketClient, } from './transport/util';

package/dist/router/client.js

@@ -1,6 +1,6 @@
 import { pushable } from 'it-pushable';
 import { msg } from '../transport/message';
-import { waitForMessage } from '../transport/ws.util';
+import { waitForMessage } from '../transport/util';
 const noop = () => { };
 function _createRecursiveProxy(callback, path) {
     const proxy = new Proxy(noop, {

package/dist/router/server.js

@@ -37,7 +37,8 @@ export async function createServer(transport, services) {
             if (msg.procedureName in service.procedures) {
                 const procedure = service.procedures[msg.procedureName];
                 const inputMessage = msg;
-                if (procedure.type === 'rpc' && Value.Check(procedure.input, inputMessage.payload)) {
+                if (procedure.type === 'rpc' &&
+                    Value.Check(procedure.input, inputMessage.payload)) {
                     // synchronous rpc
                     const response = await procedure.handler(service.state, inputMessage);
                     transport.send(response);

package/dist/router/server.util.js

@@ -1,7 +1,9 @@
-import { payloadToTransportMessage } from '../transport/message';
+import { payloadToTransportMessage, } from '../transport/message';
 import { pushable } from 'it-pushable';
 export function asClientRpc(state, proc) {
-    return (msg) => proc.handler(state, payloadToTransportMessage(msg)).then((res) => res.payload);
+    return (msg) => proc
+        .handler(state, payloadToTransportMessage(msg))
+        .then((res) => res.payload);
 }
 export function asClientStream(state, proc) {
     const i = pushable({ objectMode: true });

package/dist/transport/stream.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { OpaqueTransportMessage, TransportClientId } from './message';
+import { Transport } from './types';
+export declare class StreamTransport extends Transport {
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+    constructor(clientId: TransportClientId, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream);
+    send(msg: OpaqueTransportMessage): string;
+    close(): Promise<void>;
+}

package/dist/transport/stream.js

@@ -0,0 +1,22 @@
+import { NaiveJsonCodec } from '../codec/json';
+import { Transport } from './types';
+import readline from 'readline';
+export class StreamTransport extends Transport {
+    input;
+    output;
+    constructor(clientId, input = process.stdin, output = process.stdout) {
+        super(NaiveJsonCodec, clientId);
+        this.input = input;
+        this.output = output;
+        const rl = readline.createInterface({
+            input: this.input,
+        });
+        rl.on('line', (msg) => this.onMessage(msg));
+    }
+    send(msg) {
+        const id = msg.id;
+        this.output.write(this.codec.toStringBuf(msg) + '\n');
+        return id;
+    }
+    async close() { }
+}

package/dist/transport/stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport/stream.test.js

@@ -0,0 +1,26 @@
+import { describe, test, expect } from 'vitest';
+import stream from 'node:stream';
+import { StreamTransport } from './stream';
+import { waitForMessage } from './util';
+describe('sending and receiving across node streams works', () => {
+    test('basic send/receive', async () => {
+        const clientToServer = new stream.PassThrough();
+        const serverToClient = new stream.PassThrough();
+        const serverTransport = new StreamTransport('SERVER', clientToServer, serverToClient);
+        const clientTransport = new StreamTransport('client', serverToClient, clientToServer);
+        const msg = {
+            msg: 'cool',
+            test: 123,
+        };
+        const p = waitForMessage(serverTransport);
+        clientTransport.send({
+            id: '1',
+            from: 'client',
+            to: 'SERVER',
+            serviceName: 'test',
+            procedureName: 'test',
+            payload: msg,
+        });
+        await expect(p).resolves.toStrictEqual(msg);
+    });
+});

package/dist/transport/util.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import http from 'http';
+import WebSocket from 'isomorphic-ws';
+import { WebSocketServer } from 'ws';
+import { Transport } from './types';
+import { OpaqueTransportMessage } from './message';
+export declare function createWebSocketServer(server: http.Server): Promise<WebSocket.Server<typeof WebSocket, typeof http.IncomingMessage>>;
+export declare function onServerReady(server: http.Server, port: number): Promise<void>;
+export declare function createWsTransports(port: number, wss: WebSocketServer): Promise<[Transport, Transport]>;
+export declare function waitForSocketReady(socket: WebSocket): Promise<void>;
+export declare function createWebSocketClient(port: number): Promise<WebSocket>;
+export declare function waitForMessage(t: Transport, filter?: (msg: OpaqueTransportMessage) => boolean): Promise<unknown>;

package/dist/transport/util.js

@@ -0,0 +1,43 @@
+import WebSocket from 'isomorphic-ws';
+import { WebSocketServer } from 'ws';
+import { WebSocketTransport } from './ws';
+export async function createWebSocketServer(server) {
+    return new WebSocketServer({ server });
+}
+export async function onServerReady(server, port) {
+    return new Promise((resolve) => {
+        server.listen(port, resolve);
+    });
+}
+export async function createWsTransports(port, wss) {
+    return new Promise((resolve) => {
+        const clientSockPromise = createWebSocketClient(port);
+        wss.on('connection', async (serverSock) => {
+            resolve([
+                new WebSocketTransport(await clientSockPromise, 'client'),
+                new WebSocketTransport(serverSock, 'SERVER'),
+            ]);
+        });
+    });
+}
+export async function waitForSocketReady(socket) {
+    return new Promise((resolve) => {
+        socket.addEventListener('open', () => resolve());
+    });
+}
+export async function createWebSocketClient(port) {
+    const client = new WebSocket(`ws://localhost:${port}`);
+    await waitForSocketReady(client);
+    return client;
+}
+export async function waitForMessage(t, filter) {
+    return new Promise((resolve, _reject) => {
+        function onMessage(msg) {
+            if (!filter || filter?.(msg)) {
+                resolve(msg.payload);
+                t.removeMessageListener(onMessage);
+            }
+        }
+        t.addMessageListener(onMessage);
+    });
+}

package/dist/transport/ws.test.js

@@ -1,7 +1,7 @@
 import http from 'http';
 import { WebSocketTransport } from './ws';
 import { describe, test, expect, beforeAll, afterAll } from 'vitest';
-import { createWebSocketClient, createWebSocketServer, onServerReady, waitForMessage, } from './ws.util';
+import { createWebSocketClient, createWebSocketServer, onServerReady, waitForMessage, } from './util';
 const port = 3000;
 describe('sending and receiving across websockets works', () => {
     const server = http.createServer();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@replit/river",
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,13 +17,14 @@
   },
   "devDependencies": {
     "@types/ws": "^8.5.5",
-    "prettier": "^3.0.3",
+    "prettier": "^3.0.0",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
     "vitest": "^0.34.3"
   },
   "scripts": {
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && npx prettier . --check",
+    "format": "npx prettier . --write",
     "build": "tsc",
     "prepack": "npm run build",
     "release": "npm publish --access public",
@@ -38,16 +39,5 @@
     "jsonschema"
   ],
   "author": "Jacky Zhao",
-  "license": "MIT",
-  "prettier": {
-    "printWidth": 100,
-    "tabWidth": 2,
-    "singleQuote": true,
-    "trailingComma": "all",
-    "bracketSpacing": true,
-    "semi": true,
-    "useTabs": false,
-    "parser": "typescript",
-    "arrowParens": "always"
-  }
+  "license": "MIT"
 }