@replit/river 0.9.3 → 0.10.1

package/dist/util/testHelpers.js

@@ -1,334 +1,151 @@
-import WebSocket from 'isomorphic-ws';
-import { WebSocketServer } from 'ws';
-import { WebSocketClientTransport } from '../transport/impls/ws/client';
-import { msg, reply, } from '../transport';
-import { pushable } from 'it-pushable';
-import { Err, UNCAUGHT_ERROR, } from '../router/result';
-import { WebSocketServerTransport } from '../transport/impls/ws/server';
-/**
- * Creates a WebSocket server instance using the provided HTTP server.
- * Only used as helper for testing.
- * @param server - The HTTP server instance to use for the WebSocket server.
- * @returns A Promise that resolves to the created WebSocket server instance.
- */
-export async function createWebSocketServer(server) {
-    return new WebSocketServer({ server });
+import {
+  UNCAUGHT_ERROR
+} from "../chunk-7WJ6YLE5.js";
+import "../chunk-ORAG7IAU.js";
+import {
+  WebSocketClientTransport
+} from "../chunk-UU2Z7LDR.js";
+import {
+  WebSocketServerTransport
+} from "../chunk-RGMHF6PF.js";
+import "../chunk-WVT5QXMZ.js";
+import "../chunk-PC65ZFWJ.js";
+import "../chunk-R6H2BIMC.js";
+import "../chunk-AJQU4AZG.js";
+import {
+  msg
+} from "../chunk-ZE4MX7DF.js";
+import "../chunk-SLUSVGQH.js";
+
+// util/testHelpers.ts
+import WebSocket from "isomorphic-ws";
+import { WebSocketServer } from "ws";
+import { pushable } from "it-pushable";
+async function createWebSocketServer(server) {
+  return new WebSocketServer({ server });
 }
-/**
- * Starts listening on the given server and returns the automatically allocated port number.
- * This should only be used for testing.
- * @param server - The http server to listen on.
- * @returns A promise that resolves with the allocated port number.
- * @throws An error if a port cannot be allocated.
- */
-export async function onServerReady(server) {
-    return new Promise((resolve, reject) => {
-        server.listen(() => {
-            const addr = server.address();
-            if (typeof addr === 'object' && addr) {
-                resolve(addr.port);
-            }
-            else {
-                reject(new Error("couldn't find a port to allocate"));
-            }
-        });
+async function onServerReady(server) {
+  return new Promise((resolve, reject) => {
+    server.listen(() => {
+      const addr = server.address();
+      if (typeof addr === "object" && addr) {
+        resolve(addr.port);
+      } else {
+        reject(new Error("couldn't find a port to allocate"));
+      }
     });
+  });
 }
-/**
- * Creates a WebSocket client that connects to a local server at the specified port.
- * This should only be used for testing.
- * @param port - The port number to connect to.
- * @returns A Promise that resolves to a WebSocket instance.
- */
-export async function createLocalWebSocketClient(port) {
-    const sock = new WebSocket(`ws://localhost:${port}`);
-    sock.binaryType = 'arraybuffer';
-    return sock;
+async function createLocalWebSocketClient(port) {
+  const sock = new WebSocket(`ws://localhost:${port}`);
+  sock.binaryType = "arraybuffer";
+  return sock;
 }
-/**
- * Creates a pair of WebSocket transports for testing purposes.
- * @param port - The port number to use for the client transport. This should be acquired after starting a server via {@link createWebSocketServer}.
- * @param wss - The WebSocketServer instance to use for the server transport.
- * @returns An array containing the client and server {@link WebSocketClientTransport} instances.
- */
-export function createWsTransports(port, wss, codec) {
-    const options = codec ? { codec } : undefined;
-    return [
-        new WebSocketClientTransport(() => createLocalWebSocketClient(port), 'client', 'SERVER', options),
-        new WebSocketServerTransport(wss, 'SERVER', options),
-    ];
+function createWsTransports(port, wss, codec) {
+  const options = codec ? { codec } : void 0;
+  return [
+    new WebSocketClientTransport(
+      () => createLocalWebSocketClient(port),
+      "client",
+      "SERVER",
+      options
+    ),
+    new WebSocketServerTransport(wss, "SERVER", options)
+  ];
 }
-/**
- * Transforms an RPC procedure definition into a normal function call.
- * This should only be used for testing.
- * @template State - The type of the state object.
- * @template I - The type of the input message payload.
- * @template O - The type of the output message payload.
- * @param {State} state - The state object.
- * @param {Procedure<State, 'rpc', I, O, E, null>} proc - The RPC procedure to invoke.
- * @param {Omit<ServiceContext, 'state'>} [extendedContext] - Optional extended context.
- * @returns A function that can be used to invoke the RPC procedure.
- */
-export function asClientRpc(state, proc, extendedContext) {
-    return (msg) => proc
-        .handler({ ...extendedContext, state }, payloadToTransportMessage(msg))
-        .then((res) => res.payload)
-        .catch((err) => {
-        const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-        return Err({
-            code: UNCAUGHT_ERROR,
-            message: errorMsg,
-        });
-    });
+function payloadToTransportMessage(payload, streamId, from = "client", to = "SERVER") {
+  return msg(from, to, streamId ?? "stream", payload, "service", "procedure");
 }
-/**
- * Transforms a stream procedure definition into a pair of input and output streams.
- * Input messages can be pushed into the input stream.
- * This should only be used for testing.
- * @template State - The type of the state object.
- * @template I - The type of the input object.
- * @template O - The type of the output object.
- * @param {State} state - The state object.
- * @param {Procedure<State, 'stream', I, O, E, null>} proc - The procedure to handle the stream.
- * @param {Omit<ServiceContext, 'state'>} [extendedContext] - The extended context object.
- * @returns Pair of input and output streams.
- */
-export function asClientStream(state, proc, extendedContext) {
-    const rawInput = pushable({ objectMode: true });
-    const rawOutput = pushable({
-        objectMode: true,
-    });
-    const transportInput = pushable({
-        objectMode: true,
-    });
-    const transportOutput = pushable({
-        objectMode: true,
-    });
-    // wrapping in transport
-    (async () => {
-        for await (const rawIn of rawInput) {
-            transportInput.push(payloadToTransportMessage(rawIn));
-        }
-        transportInput.end();
-    })();
-    // unwrap from transport
-    (async () => {
-        for await (const transportRes of transportOutput) {
-            rawOutput.push(transportRes.payload);
-        }
-        rawOutput.end();
-    })();
-    // handle
-    (async () => {
-        try {
-            await proc.handler({ ...extendedContext, state }, transportInput, transportOutput);
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            transportOutput.push(reply(payloadToTransportMessage({}), Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            })));
-        }
-        transportOutput.end();
-    })();
-    return [rawInput, rawOutput];
+function createDummyTransportMessage() {
+  return payloadToTransportMessage({
+    msg: "cool",
+    test: Math.random()
+  });
 }
-/**
- * Transforms a stream procedure definition into a pair of input and output streams.
- * Input messages can be pushed into the input stream.
- * This should only be used for testing.
- * @template State - The type of the state object.
- * @template I - The type of the input object.
- * @template O - The type of the output object.
- * @param {State} state - The state object.
- * @param {Procedure<State, 'stream', I, O, E, null>} proc - The procedure to handle the stream.
- * @param {Omit<ServiceContext, 'state'>} [extendedContext] - The extended context object.
- * @returns Pair of input and output streams.
- */
-export function asClientStreamWithInitialization(state, proc, init, extendedContext) {
-    const rawInput = pushable({ objectMode: true });
-    const rawOutput = pushable({
-        objectMode: true,
-    });
-    const transportInput = pushable({
-        objectMode: true,
-    });
-    const transportOutput = pushable({
-        objectMode: true,
-    });
-    // wrapping in transport
-    (async () => {
-        for await (const rawIn of rawInput) {
-            transportInput.push(payloadToTransportMessage(rawIn));
-        }
-        transportInput.end();
-    })();
-    // unwrap from transport
-    (async () => {
-        for await (const transportRes of transportOutput) {
-            rawOutput.push(transportRes.payload);
-        }
-        rawOutput.end();
-    })();
-    // handle
-    (async () => {
-        try {
-            await proc.handler({ ...extendedContext, state }, payloadToTransportMessage(init), transportInput, transportOutput);
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            transportOutput.push(reply(payloadToTransportMessage({}), Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            })));
-        }
-        transportOutput.end();
-    })();
-    return [rawInput, rawOutput];
+async function iterNext(iter) {
+  return await iter.next().then((res) => res.value);
 }
-/**
- * Transforms a subscription procedure definition into a procedure that returns an output stream.
- * Input messages can be pushed into the input stream.
- * This should only be used for testing.
- * @template State - The type of the state object.
- * @template I - The type of the input object.
- * @template O - The type of the output object.
- * @param {State} state - The state object.
- * @param {Procedure<State, 'stream', I, O, E, null>} proc - The procedure to handle the stream.
- * @param {Omit<ServiceContext, 'state'>} [extendedContext] - The extended context object.
- * @returns A function that when passed a message, returns the output stream.
- */
-export function asClientSubscription(state, proc, extendedContext) {
-    const rawOutput = pushable({
-        objectMode: true,
-    });
-    const transportOutput = pushable({
-        objectMode: true,
-    });
-    // unwrap from transport
-    (async () => {
-        for await (const transportRes of transportOutput) {
-            rawOutput.push(transportRes.payload);
-        }
-        rawOutput.end();
-    })();
-    return async (msg) => {
-        proc
-            .handler({ ...extendedContext, state }, payloadToTransportMessage(msg), transportOutput)
-            .catch((err) => {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            return Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            });
-        });
-        return rawOutput;
-    };
+async function waitForMessage(t, filter, rejectMismatch) {
+  return new Promise((resolve, reject) => {
+    function cleanup() {
+      t.removeEventListener("message", onMessage);
+    }
+    function onMessage(msg2) {
+      if (!filter || filter?.(msg2)) {
+        cleanup();
+        resolve(msg2.payload);
+      } else if (rejectMismatch) {
+        reject(new Error("message didnt match the filter"));
+      }
+    }
+    t.addEventListener("message", onMessage);
+  });
 }
-/**
- * Transforms an upload procedure definition into a procedure that returns an input stream.
- * Input messages can be pushed into the input stream.
- * This should only be used for testing.
- * @template State - The type of the state object.
- * @template I - The type of the input object.
- * @template O - The type of the output object.
- * @param {State} state - The state object.
- * @param {Procedure<State, 'upload', I, O, E, null>} proc - The procedure to handle the stream.
- * @param {Omit<ServiceContext, 'state'>} [extendedContext] - The extended context object.
- * @returns A function that when passed a message, returns the output stream.
- */
-export function asClientUpload(state, proc, extendedContext) {
-    const rawInput = pushable({ objectMode: true });
-    const transportInput = pushable({
-        objectMode: true,
-    });
-    // wrapping in transport
-    (async () => {
-        for await (const rawIn of rawInput) {
-            transportInput.push(payloadToTransportMessage(rawIn));
-        }
-        transportInput.end();
-    })();
-    return [
-        rawInput,
-        proc
-            .handler({ ...extendedContext, state }, transportInput)
-            .then((res) => res.payload)
-            .catch((err) => {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            return Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            });
-        }),
-    ];
+function catchProcError(err) {
+  const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
+  return {
+    ok: false,
+    payload: {
+      code: UNCAUGHT_ERROR,
+      message: errorMsg
+    }
+  };
 }
-/**
- * Transforms an upload with initialization procedure definition into a procedure that returns an
- * input stream.
- * Input messages can be pushed into the input stream.
- * This should only be used for testing.
- * @template State - The type of the state object.
- * @template Init - The type of the init object.
- * @template I - The type of the input object.
- * @template O - The type of the output object.
- * @param {State} state - The state object.
- * @param {Procedure<State, 'upload', I, O, E, Init>} proc - The procedure to handle the stream.
- * @param {Omit<ServiceContext, 'state'>} [extendedContext] - The extended context object.
- * @returns A function that when passed a message, returns the output stream.
- */
-export function asClientUploadWithInitialization(state, proc, init, extendedContext) {
-    const rawInput = pushable({ objectMode: true });
-    const transportInput = pushable({
-        objectMode: true,
-    });
-    // wrapping in transport
-    (async () => {
-        for await (const rawIn of rawInput) {
-            transportInput.push(payloadToTransportMessage(rawIn));
-        }
-        transportInput.end();
-    })();
-    return [
-        rawInput,
-        proc
-            .handler({ ...extendedContext, state }, payloadToTransportMessage(init), transportInput)
-            .then((res) => res.payload)
-            .catch((err) => {
-            const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
-            return Err({
-                code: UNCAUGHT_ERROR,
-                message: errorMsg,
-            });
-        }),
-    ];
+function asClientRpc(state, proc, extendedContext) {
+  return async (msg2) => {
+    return await proc.handler({ ...extendedContext, state }, msg2).catch(catchProcError);
+  };
 }
-/**
- * Converts a payload object to a transport message with reasonable defaults.
- * This should only be used for testing.
- * @param payload - The payload object to be converted.
- * @param streamId - The optional stream ID.
- * @returns The transport message.
- */
-export function payloadToTransportMessage(payload, streamId, from = 'client', to = 'SERVER') {
-    return msg(from, to, streamId ?? 'stream', payload, 'service', 'procedure');
+function asClientStream(state, proc, init, extendedContext) {
+  const input = pushable({ objectMode: true });
+  const output = pushable({
+    objectMode: true
+  });
+  (async () => {
+    if (init) {
+      const _proc = proc;
+      await _proc.handler({ ...extendedContext, state }, init, input, output).catch((err) => output.push(catchProcError(err)));
+    } else {
+      const _proc = proc;
+      await _proc.handler({ ...extendedContext, state }, input, output).catch((err) => output.push(catchProcError(err)));
+    }
+  })();
+  return [input, output];
 }
-/**
- * Creates a dummy opaque transport message for testing purposes.
- * @returns The created opaque transport message.
- */
-export function createDummyTransportMessage() {
-    return payloadToTransportMessage({
-        msg: 'cool',
-        test: Math.random(),
-    });
+function asClientSubscription(state, proc, extendedContext) {
+  const output = pushable({
+    objectMode: true
+  });
+  return async (msg2) => {
+    (async () => {
+      return await proc.handler({ ...extendedContext, state }, msg2, output).catch((err) => output.push(catchProcError(err)));
+    })();
+    return output;
+  };
 }
-/**
- * Retrieves the next value from an async iterable iterator.
- * @param iter The async iterable iterator.
- * @returns A promise that resolves to the next value from the iterator.
- */
-export function iterNext(iter) {
-    return iter.next().then((res) => res.value);
+async function asClientUpload(state, proc, init, extendedContext) {
+  const input = pushable({ objectMode: true });
+  if (init) {
+    const _proc = proc;
+    const result = _proc.handler({ ...extendedContext, state }, init, input).catch(catchProcError);
+    return [input, result];
+  } else {
+    const _proc = proc;
+    const result = _proc.handler({ ...extendedContext, state }, input).catch(catchProcError);
+    return [input, result];
+  }
 }
+export {
+  asClientRpc,
+  asClientStream,
+  asClientSubscription,
+  asClientUpload,
+  createDummyTransportMessage,
+  createLocalWebSocketClient,
+  createWebSocketServer,
+  createWsTransports,
+  iterNext,
+  onServerReady,
+  payloadToTransportMessage,
+  waitForMessage
+};

package/package.json

@@ -1,28 +1,56 @@
 {
   "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.9.3",
+  "version": "0.10.1",
   "type": "module",
   "exports": {
-    ".": "./dist/router/index.js",
-    "./logging": "./dist/logging/index.js",
-    "./codec": "./dist/codec/index.js",
-    "./test-util": "./dist/util/testHelpers.js",
-    "./transport": "./dist/transport/index.js",
-    "./transport/ws/client": "./dist/transport/impls/ws/client.js",
-    "./transport/ws/server": "./dist/transport/impls/ws/server.js",
-    "./transport/stdio": "./dist/transport/impls/stdio/stdio.js"
+    ".": {
+      "import": "./dist/router/index.js",
+      "require": "./dist/router/index.cjs"
+    },
+    "./logging": {
+      "import": "./dist/logging/index.js",
+      "require": "./dist/logging/index.cjs"
+    },
+    "./codec": {
+      "import": "./dist/codec/index.js",
+      "require": "./dist/codec/index.cjs"
+    },
+    "./transport": {
+      "import": "./dist/transport/index.js",
+      "require": "./dist/transport/index.cjs"
+    },
+    "./transport/ws/client": {
+      "import": "./dist/transport/impls/ws/client.js",
+      "require": "./dist/transport/impls/ws/client.cjs"
+    },
+    "./transport/ws/server": {
+      "import": "./dist/transport/impls/ws/server.js",
+      "require": "./dist/transport/impls/ws/server.cjs"
+    },
+    "./transport/stdio": {
+      "import": "./dist/transport/impls/stdio/stdio.js",
+      "require": "./dist/transport/impls/stdio/stdio.cjs"
+    },
+    "./test-util": {
+      "import": "./dist/util/testHelpers.js",
+      "require": "./dist/util/testHelpers.cjs"
+    }
   },
+  "sideEffects": [
+    "./dist/logging/index.js"
+  ],
   "files": [
     "dist"
   ],
   "dependencies": {
     "@msgpack/msgpack": "^3.0.0-beta2",
-    "@sinclair/typebox": "^0.31.8",
+    "nanoid": "^4.0.2"
+  },
+  "peerDependencies": {
+    "@sinclair/typebox": "^0.31.28",
     "isomorphic-ws": "^5.0.0",
     "it-pushable": "^3.2.1",
-    "nanoid": "^4.0.2",
     "ws": "^8.13.0"
   },
   "devDependencies": {
@@ -33,6 +61,16 @@
     "typescript": "^5.2.2",
     "vitest": "^1.0.1"
   },
+  "scripts": {
+    "check": "tsc --noEmit && npx prettier . --check",
+    "format": "npx prettier . --write",
+    "build": "tsup && du -sh dist",
+    "prepack": "npm run build",
+    "release": "npm publish --access public",
+    "test:ui": "echo \"remember to go to /__vitest__ in the webview\" && vitest --ui --api.host 0.0.0.0 --api.port 3000",
+    "test": "vitest --test-timeout=500",
+    "bench": "vitest bench"
+  },
   "engines": {
     "node": ">=16"
   },
@@ -42,14 +80,5 @@
     "jsonschema"
   ],
   "author": "Jacky Zhao",
-  "license": "MIT",
-  "scripts": {
-    "check": "tsc --noEmit && npx prettier . --check",
-    "format": "npx prettier . --write",
-    "build": "rm -rf ./dist && tsc",
-    "release": "npm publish --access public",
-    "test:ui": "echo \"remember to go to /__vitest__ in the webview\" && vitest --ui --api.host 0.0.0.0 --api.port 3000",
-    "test": "vitest --test-timeout=500",
-    "bench": "vitest bench"
-  }
-}
+  "license": "MIT"
+}

package/dist/__tests__/bandwidth.bench.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=bandwidth.bench.d.ts.map

package/dist/__tests__/bandwidth.bench.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bandwidth.bench.d.ts","sourceRoot":"","sources":["../../__tests__/bandwidth.bench.ts"],"names":[],"mappings":""}