@replit/river 0.1.5 → 0.1.7

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.d.ts

@@ -27,6 +27,7 @@ export declare const TestServiceConstructor: () => {
             }>>;
             type: "rpc";
         };
+    } & {
         echo: {
             input: import("@sinclair/typebox").TObject<{
                 msg: import("@sinclair/typebox").TString;

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/__tests__/typescript-stress.test.d.ts

@@ -0,0 +1,7 @@
+import { MessageId, OpaqueTransportMessage } from '../transport/message';
+import { Transport } from '../transport/types';
+export declare class MockTransport extends Transport {
+    constructor(clientId: string);
+    send(msg: OpaqueTransportMessage): MessageId;
+    close(): Promise<void>;
+}

package/dist/__tests__/typescript-stress.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, test } from 'vitest';
+import { ServiceBuilder, serializeService } from '../router/builder';
+import { Type } from '@sinclair/typebox';
+import { reply } from '../transport/message';
+import { createServer } from '../router/server';
+import { Transport } from '../transport/types';
+import { NaiveJsonCodec } from '../codec/json';
+import { createClient } from '../router/client';
+const fnBody = {
+    type: 'rpc',
+    input: Type.Object({ a: Type.Number() }),
+    output: Type.Object({ b: Type.Number() }),
+    async handler(_state, msg) {
+        return reply(msg, { b: msg.payload.a });
+    },
+};
+// typescript is limited to max 50 constraints
+// see: https://github.com/microsoft/TypeScript/issues/33541
+const svc = () => ServiceBuilder.create('test')
+    .defineProcedure('f1', fnBody)
+    .defineProcedure('f2', fnBody)
+    .defineProcedure('f3', fnBody)
+    .defineProcedure('f4', fnBody)
+    .defineProcedure('f5', fnBody)
+    .defineProcedure('f6', fnBody)
+    .defineProcedure('f7', fnBody)
+    .defineProcedure('f8', fnBody)
+    .defineProcedure('f9', fnBody)
+    .defineProcedure('f10', fnBody)
+    .defineProcedure('f11', fnBody)
+    .defineProcedure('f12', fnBody)
+    .defineProcedure('f13', fnBody)
+    .defineProcedure('f14', fnBody)
+    .defineProcedure('f15', fnBody)
+    .defineProcedure('f16', fnBody)
+    .defineProcedure('f17', fnBody)
+    .defineProcedure('f18', fnBody)
+    .defineProcedure('f19', fnBody)
+    .defineProcedure('f20', fnBody)
+    .defineProcedure('f21', fnBody)
+    .defineProcedure('f22', fnBody)
+    .defineProcedure('f23', fnBody)
+    .defineProcedure('f24', fnBody)
+    .defineProcedure('f25', fnBody)
+    .defineProcedure('f26', fnBody)
+    .defineProcedure('f27', fnBody)
+    .defineProcedure('f28', fnBody)
+    .defineProcedure('f29', fnBody)
+    .defineProcedure('f30', fnBody)
+    .defineProcedure('f31', fnBody)
+    .defineProcedure('f32', fnBody)
+    .defineProcedure('f33', fnBody)
+    .defineProcedure('f34', fnBody)
+    .defineProcedure('f35', fnBody)
+    .defineProcedure('f36', fnBody)
+    .defineProcedure('f37', fnBody)
+    .defineProcedure('f38', fnBody)
+    .defineProcedure('f39', fnBody)
+    .defineProcedure('f40', fnBody)
+    .defineProcedure('f41', fnBody)
+    .defineProcedure('f42', fnBody)
+    .defineProcedure('f43', fnBody)
+    .defineProcedure('f44', fnBody)
+    .defineProcedure('f45', fnBody)
+    .defineProcedure('f46', fnBody)
+    .defineProcedure('f47', fnBody)
+    .defineProcedure('f48', fnBody)
+    .defineProcedure('f49', fnBody)
+    .finalize();
+// mock transport
+export class MockTransport extends Transport {
+    constructor(clientId) {
+        super(NaiveJsonCodec, clientId);
+    }
+    send(msg) {
+        const id = msg.id;
+        return id;
+    }
+    async close() { }
+}
+describe("ensure typescript doesn't give up trying to infer the types for large services", () => {
+    test('service with many procedures hits typescript limit', () => {
+        expect(serializeService(svc())).toBeTruthy();
+    });
+    test('serverclient should support many services with many procedures', async () => {
+        const listing = {
+            a: svc(),
+            b: svc(),
+            c: svc(),
+            d: svc(),
+        };
+        const server = await createServer(new MockTransport('SERVER'), listing);
+        const client = createClient(new MockTransport('client'));
+        expect(server).toBeTruthy();
+        expect(client).toBeTruthy();
+    });
+});

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/builder.d.ts

@@ -3,16 +3,17 @@ import type { Pushable } from 'it-pushable';
 import { TransportMessage } from '../transport/message';
 export type ValidProcType = 'stream' | 'rpc';
 export type ProcListing = Record<string, Procedure<object, ValidProcType, TObject, TObject>>;
-export interface Service<Name extends string = string, State extends object = object, Procs extends ProcListing = Record<string, any>> {
+export interface Service<Name extends string, State extends object, Procs extends ProcListing> {
     name: Name;
     state: State;
     procedures: Procs;
 }
-export declare function serializeService(s: Service): object;
-export type ProcHandler<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
-export type ProcInput<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['input'];
-export type ProcOutput<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['output'];
-export type ProcType<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
+export type AnyService = Service<string, object, any>;
+export declare function serializeService(s: AnyService): object;
+export type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
+export type ProcInput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['input'];
+export type ProcOutput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['output'];
+export type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
 export type Procedure<State extends object | unknown, Ty extends ValidProcType, I extends TObject, O extends TObject> = Ty extends 'rpc' ? {
     input: I;
     output: O;
@@ -33,13 +34,11 @@ export declare class ServiceBuilder<T extends Service<string, object, ProcListin
         state: InitState;
         procedures: T['procedures'];
     }>;
-    defineProcedure<ProcName extends string, Ty extends ValidProcType, I extends TObject, O extends TObject, ProcEntry = {
-        [k in ProcName]: Procedure<T['state'], Ty, I, O>;
-    }>(procName: ProcName, procDef: Procedure<T['state'], Ty, I, O>): ServiceBuilder<{
+    defineProcedure<ProcName extends string, Ty extends ValidProcType, I extends TObject, O extends TObject>(procName: ProcName, procDef: Procedure<T['state'], Ty, I, O>): ServiceBuilder<{
         name: T['name'];
         state: T['state'];
-        procedures: {
-            [Key in keyof (T['procedures'] & ProcEntry)]: (T['procedures'] & ProcEntry)[Key];
+        procedures: T['procedures'] & {
+            [k in ProcName]: Procedure<T['state'], Ty, I, O>;
         };
     }>;
     static create<Name extends string>(name: Name): ServiceBuilder<{

package/dist/router/client.d.ts

@@ -1,17 +1,17 @@
 import { Transport } from '../transport/types';
-import { ProcInput, ProcOutput, ProcType, Service } from './builder';
+import { AnyService, ProcInput, ProcOutput, ProcType } from './builder';
 import type { Pushable } from 'it-pushable';
 import { Server } from './server';
 import { Static } from '@sinclair/typebox';
-type ServiceClient<Router extends Service> = {
+type ServiceClient<Router extends AnyService> = {
     [ProcName in keyof Router['procedures']]: ProcType<Router, ProcName> extends 'rpc' ? (input: Static<ProcInput<Router, ProcName>>) => Promise<Static<ProcOutput<Router, ProcName>>> : () => Promise<[
         Pushable<Static<ProcInput<Router, ProcName>>>,
         AsyncIterator<Static<ProcOutput<Router, ProcName>>>,
         () => void
     ]>;
 };
-export type ServerClient<Srv extends Server<Record<string, Service>>> = {
+export type ServerClient<Srv extends Server<Record<string, AnyService>>> = {
     [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
 };
-export declare const createClient: <Srv extends Server<Record<string, Service<string, object, Record<string, any>>>>>(transport: Transport) => ServerClient<Srv>;
+export declare const createClient: <Srv extends Server<Record<string, AnyService>>>(transport: Transport) => ServerClient<Srv>;
 export {};

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.d.ts

@@ -1,7 +1,7 @@
 import { Transport } from '../transport/types';
-import { Service } from './builder';
+import { AnyService } from './builder';
 export interface Server<Services> {
     services: Services;
     close(): Promise<void>;
 }
-export declare function createServer<Services extends Record<string, Service>>(transport: Transport, services: Services): Promise<Server<Services>>;
+export declare function createServer<Services extends Record<string, AnyService>>(transport: Transport, services: Services): Promise<Server<Services>>;

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.7",
   "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"
 }