@replit/river 0.2.0 → 0.2.2

package/README.md

@@ -6,13 +6,3 @@ It's like tRPC but...
 - with full-duplex streaming
 - with support for service multiplexing
 - over WebSockets
-
-## Levels of abstraction
-
-- Router
-- Service
-- Procedure
-
-## TODO
-
-- support broadcast

package/dist/__tests__/integration.test.d.ts

@@ -1,4 +1,3 @@
-import { TransportMessage } from '../transport/message';
 export declare const EchoRequest: import("@sinclair/typebox").TObject<{
     msg: import("@sinclair/typebox").TString;
     ignore: import("@sinclair/typebox").TBoolean;
@@ -21,9 +20,9 @@ export declare const TestServiceConstructor: () => {
             }>;
             handler: (context: import("..").ServiceContextWithState<{
                 count: number;
-            }>, input: TransportMessage<{
+            }>, input: import("../transport/message").TransportMessage<{
                 n: number;
-            }>) => Promise<TransportMessage<{
+            }>) => Promise<import("../transport/message").TransportMessage<{
                 result: number;
             }>>;
             type: "rpc";
@@ -39,10 +38,10 @@ export declare const TestServiceConstructor: () => {
             }>;
             handler: (context: import("..").ServiceContextWithState<{
                 count: number;
-            }>, input: AsyncIterable<TransportMessage<{
+            }>, input: AsyncIterable<import("../transport/message").TransportMessage<{
                 msg: string;
                 ignore: boolean;
-            }>>, output: import("it-pushable").Pushable<TransportMessage<{
+            }>>, output: import("it-pushable").Pushable<import("../transport/message").TransportMessage<{
                 response: string;
             }>, void, unknown>) => Promise<void>;
             type: "stream";

package/dist/codec/codec.test.js

@@ -20,4 +20,10 @@ describe('naive json codec', () => {
         };
         expect(NaiveJsonCodec.fromStringBuf(NaiveJsonCodec.toStringBuf(msg))).toStrictEqual(msg);
     });
+    test('invalid json returns null', () => {
+        expect(NaiveJsonCodec.fromStringBuf('')).toBeNull();
+        expect(NaiveJsonCodec.fromStringBuf('[')).toBeNull();
+        expect(NaiveJsonCodec.fromStringBuf('[{}')).toBeNull();
+        expect(NaiveJsonCodec.fromStringBuf('{"a":1}[]')).toBeNull();
+    });
 });

package/dist/codec/json.js

@@ -1,4 +1,11 @@
 export const NaiveJsonCodec = {
     toStringBuf: JSON.stringify,
-    fromStringBuf: JSON.parse,
+    fromStringBuf: (s) => {
+        try {
+            return JSON.parse(s);
+        }
+        catch {
+            return null;
+        }
+    },
 };

package/dist/codec/types.d.ts

@@ -1,4 +1,4 @@
 export interface Codec {
     toStringBuf(obj: object): string;
-    fromStringBuf(buf: string): object;
+    fromStringBuf(buf: string): object | null;
 }

package/dist/logging/index.d.ts

@@ -0,0 +1,15 @@
+declare const LoggingLevels: {
+    readonly info: 0;
+    readonly warn: 1;
+    readonly error: 2;
+};
+type LoggingLevel = keyof typeof LoggingLevels;
+export type Logger = {
+    minLevel: LoggingLevel;
+} & {
+    [key in LoggingLevel]: (msg: string) => void;
+};
+export declare let log: Logger | undefined;
+export declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
+export declare function setLevel(level: LoggingLevel): void;
+export {};

package/dist/logging/index.js

@@ -0,0 +1,29 @@
+const LoggingLevels = {
+    info: 0,
+    warn: 1,
+    error: 2,
+};
+export let log;
+const defaultLoggingLevel = 'warn';
+export function bindLogger(write, color) {
+    const info = color ? '\u001b[37minfo\u001b[0m' : 'info';
+    const warn = color ? '\u001b[33mwarn\u001b[0m' : 'warn';
+    const error = color ? '\u001b[31merr\u001b[0m' : 'err';
+    log = {
+        info: (msg) => log &&
+            LoggingLevels[log.minLevel] <= 0 &&
+            write(`[river:${info}] ${msg}`),
+        warn: (msg) => log &&
+            LoggingLevels[log.minLevel] <= 1 &&
+            write(`[river:${warn}] ${msg}`),
+        error: (msg) => log &&
+            LoggingLevels[log.minLevel] <= 2 &&
+            write(`[river:${error}] ${msg}`),
+        minLevel: log?.minLevel ?? defaultLoggingLevel,
+    };
+}
+export function setLevel(level) {
+    if (log) {
+        log.minLevel = level;
+    }
+}

package/dist/router/server.js

@@ -1,12 +1,15 @@
 import { Value } from '@sinclair/typebox/value';
 import { pushable } from 'it-pushable';
+import { log } from '../logging';
 export async function createServer(transport, services, extendedContext) {
     const contextMap = new Map();
     const streamMap = new Map();
     function getContext(service) {
         const context = contextMap.get(service);
         if (!context) {
-            throw new Error(`No context found for ${service.name}`);
+            const err = `No context found for ${service.name}`;
+            log?.error(err);
+            throw new Error(err);
         }
         return context;
     }
@@ -38,7 +41,6 @@ export async function createServer(transport, services, extendedContext) {
         }
     }
     const handler = async (msg) => {
-        // TODO: log msgs received
         if (msg.to !== 'SERVER') {
             return;
         }
@@ -66,10 +68,11 @@ export async function createServer(transport, services, extendedContext) {
                     return;
                 }
                 else {
-                    // TODO: log invalid payload
+                    log?.error(`${transport.clientId} -- procedure ${msg.serviceName}.${msg.procedureName} received invalid payload: ${inputMessage.payload}`);
                 }
             }
         }
+        log?.warn(`${transport.clientId} -- couldn't find a matching procedure for ${msg.serviceName}.${msg.procedureName}`);
     };
     transport.addMessageListener(handler);
     return {

package/dist/transport/types.js

@@ -1,5 +1,6 @@
 import { Value } from '@sinclair/typebox/value';
 import { OpaqueTransportMessageSchema, TransportAckSchema, ack, } from './message';
+import { log } from '../logging';
 export class Transport {
     codec;
     clientId;
@@ -12,15 +13,20 @@ export class Transport {
         this.clientId = clientId;
     }
     onMessage(msg) {
-        // TODO: try catch from string buf
-        const parsedMsg = this.codec.fromStringBuf(msg.toString());
+        const parsedMsg = this.codec.fromStringBuf(msg);
+        if (parsedMsg === null) {
+            log?.warn(`${this.clientId} -- received malformed msg: ${msg}`);
+            return;
+        }
         if (Value.Check(TransportAckSchema, parsedMsg)) {
             // process ack
+            log?.info(`${this.clientId} -- received ack: ${msg}`);
             if (this.sendBuffer.has(parsedMsg.ack)) {
                 this.sendBuffer.delete(parsedMsg.ack);
             }
         }
         else if (Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
+            log?.info(`${this.clientId} -- received msg: ${msg}`);
             // ignore if not for us
             if (parsedMsg.to !== this.clientId && parsedMsg.to !== 'broadcast') {
                 return;
@@ -29,10 +35,12 @@ export class Transport {
             for (const handler of this.handlers) {
                 handler(parsedMsg);
             }
-            this.send(ack(parsedMsg));
+            const ackMsg = ack(parsedMsg);
+            ackMsg.from = this.clientId;
+            this.send(ackMsg);
         }
         else {
-            // TODO: warn on malformed
+            log?.warn(`${this.clientId} -- received invalid transport msg: ${msg}`);
         }
     }
     addMessageListener(handler) {

package/dist/transport/ws.js

@@ -1,5 +1,6 @@
 import { Transport } from './types';
 import { NaiveJsonCodec } from '../codec/json';
+import { log } from '../logging';
 const defaultOptions = {
     retryIntervalMs: 250,
 };
@@ -22,6 +23,7 @@ export class WebSocketTransport extends Transport {
     async tryConnect() {
         // wait until it's ready or we get an error
         this.reconnectPromise ??= new Promise(async (resolve) => {
+            log?.info(`${this.clientId} -- establishing a new websocket`);
             const ws = await this.wsGetter();
             if (ws.readyState === ws.OPEN) {
                 return resolve({ ws });
@@ -45,6 +47,7 @@ export class WebSocketTransport extends Transport {
         const res = await this.reconnectPromise;
         // only send if we resolved a valid websocket
         if ('ws' in res && res.ws.readyState === res.ws.OPEN) {
+            log?.info(`${this.clientId} -- websocket ok`);
             this.ws = res.ws;
             this.ws.onmessage = (msg) => this.onMessage(msg.data.toString());
             this.ws.onclose = () => {
@@ -55,33 +58,42 @@ export class WebSocketTransport extends Transport {
             for (const id of this.sendQueue) {
                 const msg = this.sendBuffer.get(id);
                 if (!msg) {
-                    throw new Error('tried to resend a message we received an ack for');
+                    const err = 'tried to resend a message we received an ack for';
+                    log?.error(err);
+                    throw new Error(err);
                 }
+                log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
                 this.ws.send(this.codec.toStringBuf(msg));
             }
             this.sendQueue = [];
             return;
         }
         // otherwise try and reconnect again
+        log?.warn(`${this.clientId} -- websocket failed, trying again in ${this.options.retryIntervalMs}ms`);
         this.reconnectPromise = undefined;
         setTimeout(() => this.tryConnect(), this.options.retryIntervalMs);
     }
     send(msg) {
         const id = msg.id;
         if (this.destroyed) {
-            throw new Error('ws is destroyed, cant send');
+            const err = 'ws is destroyed, cant send';
+            log?.error(err);
+            throw new Error(err);
         }
         this.sendBuffer.set(id, msg);
         if (this.ws && this.ws.readyState === this.ws.OPEN) {
+            log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
             this.ws.send(this.codec.toStringBuf(msg));
         }
         else {
+            log?.info(`${this.clientId} -- transport not ready, queuing ${JSON.stringify(msg)}`);
             this.sendQueue.push(id);
             this.tryConnect().catch();
         }
         return id;
     }
     async close() {
+        log?.info('manually closed ws');
         this.destroyed = true;
         return this.ws?.close();
     }

package/package.json

@@ -2,10 +2,10 @@
   "name": "@replit/river",
   "sideEffects": false,
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],