@replit/river 0.9.2 → 0.10.0

package/dist/__tests__/fixtures/services.d.ts

@@ -23,11 +23,11 @@ export declare const TestServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
-            }>, input: import("../../transport/message").TransportMessage<{
+            }>, input: {
                 n: number;
-            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }) => Promise<import("../../router/result").Result<{
                 result: number;
-            }, never>>>;
+            }, never>>;
             type: "rpc";
         };
     } & {
@@ -43,13 +43,13 @@ export declare const TestServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
-            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+            }>, input: AsyncIterableIterator<{
                 end?: boolean | undefined;
                 msg: string;
                 ignore: boolean;
-            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>, output: import("it-pushable").Pushable<import("../../router/result").Result<{
                 response: string;
-            }, never>>, void, unknown>) => Promise<void>;
+            }, never>, void, unknown>) => Promise<void>;
             type: "stream";
         };
     } & {
@@ -68,15 +68,15 @@ export declare const TestServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: number;
-            }>, init: import("../../transport/message").TransportMessage<{
+            }>, init: {
                 prefix: string;
-            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+            }, input: AsyncIterableIterator<{
                 end?: boolean | undefined;
                 msg: string;
                 ignore: boolean;
-            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>, output: import("it-pushable").Pushable<import("../../router/result").Result<{
                 response: string;
-            }, never>>, void, unknown>) => Promise<void>;
+            }, never>, void, unknown>) => Promise<void>;
             type: "stream";
         };
     };
@@ -97,11 +97,11 @@ export declare const OrderingServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 msgs: number[];
-            }>, input: import("../../transport/message").TransportMessage<{
+            }>, input: {
                 n: number;
-            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }) => Promise<import("../../router/result").Result<{
                 n: number;
-            }, never>>>;
+            }, never>>;
             type: "rpc";
         };
     } & {
@@ -113,9 +113,9 @@ export declare const OrderingServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 msgs: number[];
-            }>, input: import("../../transport/message").TransportMessage<{}>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>, input: {}) => Promise<import("../../router/result").Result<{
                 msgs: number[];
-            }, never>>>;
+            }, never>>;
             type: "rpc";
         };
     };
@@ -132,11 +132,11 @@ export declare const BinaryFileServiceConstructor: () => {
                 contents: import("@sinclair/typebox").TUint8Array;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: import("../../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: {
                 file: string;
-            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }) => Promise<import("../../router/result").Result<{
                 contents: Uint8Array;
-            }, never>>>;
+            }, never>>;
             type: "rpc";
         };
     };
@@ -162,10 +162,10 @@ export declare const FallibleServiceConstructor: () => {
                     test: import("@sinclair/typebox").TString;
                 }>;
             }>;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: import("../../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: {
                 a: number;
                 b: number;
-            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }) => Promise<import("../../router/result").Result<{
                 result: number;
             }, {
                 message: string;
@@ -173,7 +173,7 @@ export declare const FallibleServiceConstructor: () => {
                 extras: {
                     test: string;
                 };
-            }>>>;
+            }>>;
             type: "rpc";
         };
     } & {
@@ -190,16 +190,16 @@ export declare const FallibleServiceConstructor: () => {
                 code: import("@sinclair/typebox").TLiteral<"STREAM_ERROR">;
                 message: import("@sinclair/typebox").TString;
             }>;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterableIterator<{
                 msg: string;
                 throwResult: boolean;
                 throwError: boolean;
-            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>, output: import("it-pushable").Pushable<import("../../router/result").Result<{
                 response: string;
             }, {
                 message: string;
                 code: "STREAM_ERROR";
-            }>>, void, unknown>) => Promise<void>;
+            }>, void, unknown>) => Promise<void>;
             type: "stream";
         };
     };
@@ -220,11 +220,11 @@ export declare const SubscribableServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: Observable<number>;
-            }>, input: import("../../transport/message").TransportMessage<{
+            }>, input: {
                 n: number;
-            }>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }) => Promise<import("../../router/result").Result<{
                 result: number;
-            }, never>>>;
+            }, never>>;
             type: "rpc";
         };
     } & {
@@ -236,9 +236,9 @@ export declare const SubscribableServiceConstructor: () => {
             errors: import("@sinclair/typebox").TNever;
             handler: (context: import("../../router").ServiceContextWithState<{
                 count: Observable<number>;
-            }>, input: import("../../transport/message").TransportMessage<{}>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>, input: {}, output: import("it-pushable").Pushable<import("../../router/result").Result<{
                 result: number;
-            }, never>>, void, unknown>) => Promise<void>;
+            }, never>, void, unknown>) => Promise<void>;
             type: "subscription";
         };
     };
@@ -255,11 +255,11 @@ export declare const UploadableServiceConstructor: () => {
                 result: import("@sinclair/typebox").TNumber;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterableIterator<{
                 n: number;
-            }>>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>) => Promise<import("../../router/result").Result<{
                 result: number;
-            }, never>>>;
+            }, never>>;
             type: "upload";
         };
     } & {
@@ -274,13 +274,13 @@ export declare const UploadableServiceConstructor: () => {
                 result: import("@sinclair/typebox").TString;
             }>;
             errors: import("@sinclair/typebox").TNever;
-            handler: (context: import("../../router").ServiceContextWithState<{}>, init: import("../../transport/message").TransportMessage<{
+            handler: (context: import("../../router").ServiceContextWithState<{}>, init: {
                 prefix: string;
-            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+            }, input: AsyncIterableIterator<{
                 n: number;
-            }>>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+            }>) => Promise<import("../../router/result").Result<{
                 result: string;
-            }, never>>>;
+            }, never>>;
             type: "upload";
         };
     };

package/dist/__tests__/fixtures/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiExB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B5B,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC1B,CAAC"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../../__tests__/fixtures/services.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AACH,eAAO,MAAM,YAAY;;EAA2C,CAAC;AAErE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CpB,CAAC;AAEhB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBxB,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEhB,eAAO,MAAM,WAAW,gBAAgB,CAAC;AACzC,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDxB,CAAC;AAEhB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B5B,CAAC;AAEhB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+B1B,CAAC"}

package/dist/__tests__/fixtures/services.js

@@ -1,6 +1,5 @@
 import { Type } from '@sinclair/typebox';
 import { ServiceBuilder } from '../../router/builder';
-import { reply } from '../../transport/message';
 import { Err, Ok } from '../../router/result';
 import { Observable } from './observable';
 export const EchoRequest = Type.Object({
@@ -18,10 +17,9 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
     input: Type.Object({ n: Type.Number() }),
     output: Type.Object({ result: Type.Number() }),
     errors: Type.Never(),
-    async handler(ctx, msg) {
-        const { n } = msg.payload;
+    async handler(ctx, { n }) {
         ctx.state.count += n;
-        return reply(msg, Ok({ result: ctx.state.count }));
+        return Ok({ result: ctx.state.count });
     },
 })
     .defineProcedure('echo', {
@@ -30,12 +28,11 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
     output: EchoResponse,
     errors: Type.Never(),
     async handler(_ctx, msgStream, returnStream) {
-        for await (const msg of msgStream) {
-            const req = msg.payload;
-            if (!req.ignore) {
-                returnStream.push(reply(msg, Ok({ response: req.msg })));
+        for await (const { ignore, msg, end } of msgStream) {
+            if (!ignore) {
+                returnStream.push(Ok({ response: msg }));
             }
-            if (req.end) {
+            if (end) {
                 returnStream.end();
             }
         }
@@ -48,10 +45,9 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
     output: EchoResponse,
     errors: Type.Never(),
     async handler(_ctx, init, msgStream, returnStream) {
-        for await (const msg of msgStream) {
-            const req = msg.payload;
-            if (!req.ignore) {
-                returnStream.push(reply(msg, Ok({ response: `${init.payload.prefix} ${req.msg}` })));
+        for await (const { ignore, msg } of msgStream) {
+            if (!ignore) {
+                returnStream.push(Ok({ response: `${init.prefix} ${msg}` }));
             }
         }
     },
@@ -66,10 +62,9 @@ export const OrderingServiceConstructor = () => ServiceBuilder.create('test')
     input: Type.Object({ n: Type.Number() }),
     output: Type.Object({ n: Type.Number() }),
     errors: Type.Never(),
-    async handler(ctx, msg) {
-        const { n } = msg.payload;
+    async handler(ctx, { n }) {
         ctx.state.msgs.push(n);
-        return reply(msg, Ok({ n }));
+        return Ok({ n });
     },
 })
     .defineProcedure('getAll', {
@@ -77,8 +72,8 @@ export const OrderingServiceConstructor = () => ServiceBuilder.create('test')
     input: Type.Object({}),
     output: Type.Object({ msgs: Type.Array(Type.Number()) }),
     errors: Type.Never(),
-    async handler(ctx, msg) {
-        return reply(msg, Ok({ msgs: ctx.state.msgs }));
+    async handler(ctx, _msg) {
+        return Ok({ msgs: ctx.state.msgs });
     },
 })
     .finalize();
@@ -88,9 +83,9 @@ export const BinaryFileServiceConstructor = () => ServiceBuilder.create('bin')
     input: Type.Object({ file: Type.String() }),
     output: Type.Object({ contents: Type.Uint8Array() }),
     errors: Type.Never(),
-    async handler(_ctx, msg) {
-        const bytes = new TextEncoder().encode(`contents for file ${msg.payload.file}`);
-        return reply(msg, Ok({ contents: bytes }));
+    async handler(_ctx, { file }) {
+        const bytes = new TextEncoder().encode(`contents for file ${file}`);
+        return Ok({ contents: bytes });
     },
 })
     .finalize();
@@ -109,20 +104,16 @@ export const FallibleServiceConstructor = () => ServiceBuilder.create('fallible'
             extras: Type.Object({ test: Type.String() }),
         }),
     ]),
-    async handler(_ctx, msg) {
-        const { a, b } = msg.payload;
+    async handler(_ctx, { a, b }) {
         if (b === 0) {
-            return reply(msg, {
-                ok: false,
-                payload: {
-                    code: DIV_BY_ZERO,
-                    message: 'Cannot divide by zero',
-                    extras: { test: 'abc' },
-                },
+            return Err({
+                code: DIV_BY_ZERO,
+                message: 'Cannot divide by zero',
+                extras: { test: 'abc' },
             });
         }
         else {
-            return reply(msg, Ok({ result: a / b }));
+            return Ok({ result: a / b });
         }
     },
 })
@@ -141,19 +132,18 @@ export const FallibleServiceConstructor = () => ServiceBuilder.create('fallible'
         }),
     ]),
     async handler(_ctx, msgStream, returnStream) {
-        for await (const msg of msgStream) {
-            const req = msg.payload;
-            if (req.throwError) {
+        for await (const { msg, throwError, throwResult } of msgStream) {
+            if (throwError) {
                 throw new Error('some message');
             }
-            else if (req.throwResult) {
-                returnStream.push(reply(msg, Err({
+            else if (throwResult) {
+                returnStream.push(Err({
                     code: STREAM_ERROR,
                     message: 'field throwResult was set to true',
-                })));
+                }));
             }
             else {
-                returnStream.push(reply(msg, Ok({ response: req.msg })));
+                returnStream.push(Ok({ response: msg }));
             }
         }
     },
@@ -168,10 +158,9 @@ export const SubscribableServiceConstructor = () => ServiceBuilder.create('subsc
     input: Type.Object({ n: Type.Number() }),
     output: Type.Object({ result: Type.Number() }),
     errors: Type.Never(),
-    async handler(ctx, msg) {
-        const { n } = msg.payload;
+    async handler(ctx, { n }) {
         ctx.state.count.set((prev) => prev + n);
-        return reply(msg, Ok({ result: ctx.state.count.get() }));
+        return Ok({ result: ctx.state.count.get() });
     },
 })
     .defineProcedure('value', {
@@ -179,9 +168,9 @@ export const SubscribableServiceConstructor = () => ServiceBuilder.create('subsc
     input: Type.Object({}),
     output: Type.Object({ result: Type.Number() }),
     errors: Type.Never(),
-    async handler(ctx, msg, returnStream) {
+    async handler(ctx, _msg, returnStream) {
         ctx.state.count.observe((count) => {
-            returnStream.push(reply(msg, Ok({ result: count })));
+            returnStream.push(Ok({ result: count }));
         });
     },
 })
@@ -195,13 +184,10 @@ export const UploadableServiceConstructor = () => ServiceBuilder.create('uploada
     errors: Type.Never(),
     async handler(_ctx, msgStream) {
         let result = 0;
-        let lastMsg;
-        for await (const msg of msgStream) {
-            const { n } = msg.payload;
+        for await (const { n } of msgStream) {
             result += n;
-            lastMsg = msg;
         }
-        return reply(lastMsg, Ok({ result: result }));
+        return Ok({ result: result });
     },
 })
     .defineProcedure('addMultipleWithPrefix', {
@@ -212,13 +198,10 @@ export const UploadableServiceConstructor = () => ServiceBuilder.create('uploada
     errors: Type.Never(),
     async handler(_ctx, init, msgStream) {
         let result = 0;
-        let lastMsg;
-        for await (const msg of msgStream) {
-            const { n } = msg.payload;
+        for await (const { n } of msgStream) {
             result += n;
-            lastMsg = msg;
         }
-        return reply(lastMsg, Ok({ result: init.payload.prefix + ' ' + result }));
+        return Ok({ result: init.prefix + ' ' + result });
     },
 })
     .finalize();

package/dist/__tests__/handler.test.js

@@ -1,13 +1,12 @@
-import { asClientRpc, asClientStream, asClientStreamWithInitialization, asClientSubscription, asClientUpload, asClientUploadWithInitialization, iterNext, } from '../util/testHelpers';
+import { asClientRpc, asClientStream, asClientSubscription, asClientUpload, iterNext, } from '../util/testHelpers';
 import { assert, describe, expect, test } from 'vitest';
 import { DIV_BY_ZERO, FallibleServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, UploadableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
 import { UNCAUGHT_ERROR } from '../router/result';
 import { Observable } from './fixtures/observable';
 describe('server-side test', () => {
     const service = TestServiceConstructor();
-    const initialState = { count: 0 };
     test('rpc basic', async () => {
-        const add = asClientRpc(initialState, service.procedures.add);
+        const add = asClientRpc({ count: 0 }, service.procedures.add);
         const result = await add({ n: 3 });
         assert(result.ok);
         expect(result.payload).toStrictEqual({ result: 3 });
@@ -35,7 +34,7 @@ describe('server-side test', () => {
         });
     });
     test('stream basic', async () => {
-        const [input, output] = asClientStream(initialState, service.procedures.echo);
+        const [input, output] = asClientStream({ count: 0 }, service.procedures.echo);
         input.push({ msg: 'abc', ignore: false });
         input.push({ msg: 'def', ignore: true });
         input.push({ msg: 'ghi', ignore: false });
@@ -49,7 +48,7 @@ describe('server-side test', () => {
         expect(output.readableLength).toBe(0);
     });
     test('stream with initialization', async () => {
-        const [input, output] = asClientStreamWithInitialization(initialState, service.procedures.echoWithPrefix, { prefix: 'test' });
+        const [input, output] = asClientStream({ count: 0 }, service.procedures.echoWithPrefix, { prefix: 'test' });
         input.push({ msg: 'abc', ignore: false });
         input.push({ msg: 'def', ignore: true });
         input.push({ msg: 'ghi', ignore: false });
@@ -101,7 +100,7 @@ describe('server-side test', () => {
     });
     test('uploads', async () => {
         const service = UploadableServiceConstructor();
-        const [input, result] = asClientUpload({}, service.procedures.addMultiple);
+        const [input, result] = await asClientUpload({}, service.procedures.addMultiple);
         input.push({ n: 1 });
         input.push({ n: 2 });
         input.end();
@@ -109,7 +108,7 @@ describe('server-side test', () => {
     });
     test('uploads with initialization', async () => {
         const service = UploadableServiceConstructor();
-        const [input, result] = asClientUploadWithInitialization({}, service.procedures.addMultipleWithPrefix, { prefix: 'test' });
+        const [input, result] = await asClientUpload({}, service.procedures.addMultipleWithPrefix, { prefix: 'test' });
         input.push({ n: 1 });
         input.push({ n: 2 });
         input.end();