@replit/river 0.8.1 → 0.9.1

package/dist/__tests__/e2e.test.js

@@ -3,7 +3,7 @@ import { createLocalWebSocketClient, createWebSocketServer, createWsTransports,
 import { createServer } from '../router/server';
 import { createClient } from '../router/client';
 import http from 'http';
-import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
+import { BinaryFileServiceConstructor, DIV_BY_ZERO, FallibleServiceConstructor, OrderingServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, UploadableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
 import { UNCAUGHT_ERROR } from '../router/result';
 import { codecs } from '../codec/codec.test';
 import { WebSocketClientTransport } from '../transport/impls/ws/client';
@@ -100,6 +100,31 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             server,
         });
     });
+    test('stream with init message', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { test: TestServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [input, output, close] = await client.test.echoWithPrefix.stream({
+            prefix: 'test',
+        });
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        const result1 = await iterNext(output);
+        assert(result1.ok);
+        expect(result1.payload).toStrictEqual({ response: 'test abc' });
+        const result2 = await iterNext(output);
+        assert(result2.ok);
+        expect(result2.payload).toStrictEqual({ response: 'test ghi' });
+        close();
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
+    });
     test('fallible stream', async () => {
         const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: FallibleServiceConstructor() };
@@ -169,6 +194,44 @@ describe.each(codecs)('client <-> server integration test ($name codec)', async
             server,
         });
     });
+    test('upload', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { uploadable: UploadableServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [addStream, addResult] = await client.uploadable.addMultiple.upload();
+        addStream.push({ n: 1 });
+        addStream.push({ n: 2 });
+        addStream.end();
+        const result = await addResult;
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 3 });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
+    });
+    test('upload with init message', async () => {
+        const [clientTransport, serverTransport] = getTransports();
+        const serviceDefs = { uploadable: UploadableServiceConstructor() };
+        const server = await createServer(serverTransport, serviceDefs);
+        const client = createClient(clientTransport);
+        const [addStream, addResult] = await client.uploadable.addMultipleWithPrefix.upload({
+            prefix: 'test',
+        });
+        addStream.push({ n: 1 });
+        addStream.push({ n: 2 });
+        addStream.end();
+        const result = await addResult;
+        assert(result.ok);
+        expect(result.payload).toStrictEqual({ result: 'test 3' });
+        await testFinishesCleanly({
+            clientTransports: [clientTransport],
+            serverTransport,
+            server,
+        });
+    });
     test('message order is preserved in the face of disconnects', async () => {
         const [clientTransport, serverTransport] = getTransports();
         const serviceDefs = { test: OrderingServiceConstructor() };

package/dist/__tests__/fixtures/cleanup.js

@@ -6,7 +6,7 @@ const waitUntilOptions = {
 export async function ensureTransportIsClean(t) {
     expect(t.state, `transport ${t.clientId} should be closed after the test`).to.not.equal('open');
     expect(t.connections, `transport ${t.clientId} should not have open connections after the test`).toStrictEqual(new Map());
-    expect(t.messageHandlers, `transport ${t.clientId} should not have open message handlers after the test`).toStrictEqual(new Set());
+    expect(t.eventDispatcher.numberOfListeners('message'), `transport ${t.clientId} should not have open message handlers after the test`).equal(0);
 }
 export async function waitUntil(valueGetter, expected, message) {
     return vi

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

@@ -52,6 +52,33 @@ export declare const TestServiceConstructor: () => {
             }, never>>, void, unknown>) => Promise<void>;
             type: "stream";
         };
+    } & {
+        echoWithPrefix: {
+            init: import("@sinclair/typebox").TObject<{
+                prefix: import("@sinclair/typebox").TString;
+            }>;
+            input: import("@sinclair/typebox").TObject<{
+                msg: import("@sinclair/typebox").TString;
+                ignore: import("@sinclair/typebox").TBoolean;
+                end: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                response: import("@sinclair/typebox").TString;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{
+                count: number;
+            }>, init: import("../../transport/message").TransportMessage<{
+                prefix: string;
+            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                end?: boolean | undefined;
+                msg: string;
+                ignore: boolean;
+            }>>, output: import("it-pushable").Pushable<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                response: string;
+            }, never>>, void, unknown>) => Promise<void>;
+            type: "stream";
+        };
     };
 };
 export declare const OrderingServiceConstructor: () => {
@@ -216,4 +243,46 @@ export declare const SubscribableServiceConstructor: () => {
         };
     };
 };
+export declare const UploadableServiceConstructor: () => {
+    name: "uploadable";
+    state: {};
+    procedures: {
+        addMultiple: {
+            input: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TNumber;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{}>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                n: number;
+            }>>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                result: number;
+            }, never>>>;
+            type: "upload";
+        };
+    } & {
+        addMultipleWithPrefix: {
+            init: import("@sinclair/typebox").TObject<{
+                prefix: import("@sinclair/typebox").TString;
+            }>;
+            input: import("@sinclair/typebox").TObject<{
+                n: import("@sinclair/typebox").TNumber;
+            }>;
+            output: import("@sinclair/typebox").TObject<{
+                result: import("@sinclair/typebox").TString;
+            }>;
+            errors: import("@sinclair/typebox").TNever;
+            handler: (context: import("../../router").ServiceContextWithState<{}>, init: import("../../transport/message").TransportMessage<{
+                prefix: string;
+            }>, input: AsyncIterable<import("../../transport/message").TransportMessage<{
+                n: number;
+            }>>) => Promise<import("../../transport/message").TransportMessage<import("../../router/result").Result<{
+                result: string;
+            }, never>>>;
+            type: "upload";
+        };
+    };
+};
 //# sourceMappingURL=services.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCpB,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"}
+{"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"}

package/dist/__tests__/fixtures/services.js

@@ -40,6 +40,21 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
             }
         }
     },
+})
+    .defineProcedure('echoWithPrefix', {
+    type: 'stream',
+    init: Type.Object({ prefix: Type.String() }),
+    input: EchoRequest,
+    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}` })));
+            }
+        }
+    },
 })
     .finalize();
 export const OrderingServiceConstructor = () => ServiceBuilder.create('test')
@@ -171,3 +186,39 @@ export const SubscribableServiceConstructor = () => ServiceBuilder.create('subsc
     },
 })
     .finalize();
+export const UploadableServiceConstructor = () => ServiceBuilder.create('uploadable')
+    .initialState({})
+    .defineProcedure('addMultiple', {
+    type: 'upload',
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ result: Type.Number() }),
+    errors: Type.Never(),
+    async handler(_ctx, msgStream) {
+        let result = 0;
+        let lastMsg;
+        for await (const msg of msgStream) {
+            const { n } = msg.payload;
+            result += n;
+            lastMsg = msg;
+        }
+        return reply(lastMsg, Ok({ result: result }));
+    },
+})
+    .defineProcedure('addMultipleWithPrefix', {
+    type: 'upload',
+    init: Type.Object({ prefix: Type.String() }),
+    input: Type.Object({ n: Type.Number() }),
+    output: Type.Object({ result: Type.String() }),
+    errors: Type.Never(),
+    async handler(_ctx, init, msgStream) {
+        let result = 0;
+        let lastMsg;
+        for await (const msg of msgStream) {
+            const { n } = msg.payload;
+            result += n;
+            lastMsg = msg;
+        }
+        return reply(lastMsg, Ok({ result: init.payload.prefix + ' ' + result }));
+    },
+})
+    .finalize();

package/dist/__tests__/handler.test.js

@@ -1,6 +1,6 @@
-import { asClientRpc, asClientStream, asClientSubscription, iterNext, } from '../util/testHelpers';
+import { asClientRpc, asClientStream, asClientStreamWithInitialization, asClientSubscription, asClientUpload, asClientUploadWithInitialization, iterNext, } from '../util/testHelpers';
 import { assert, describe, expect, test } from 'vitest';
-import { DIV_BY_ZERO, FallibleServiceConstructor, STREAM_ERROR, SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
+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', () => {
@@ -48,6 +48,20 @@ describe('server-side test', () => {
         expect(result2.payload).toStrictEqual({ response: 'ghi' });
         expect(output.readableLength).toBe(0);
     });
+    test('stream with initialization', async () => {
+        const [input, output] = asClientStreamWithInitialization(initialState, service.procedures.echoWithPrefix, { prefix: 'test' });
+        input.push({ msg: 'abc', ignore: false });
+        input.push({ msg: 'def', ignore: true });
+        input.push({ msg: 'ghi', ignore: false });
+        input.end();
+        const result1 = await iterNext(output);
+        assert(result1 && result1.ok);
+        expect(result1.payload).toStrictEqual({ response: 'test abc' });
+        const result2 = await iterNext(output);
+        assert(result2 && result2.ok);
+        expect(result2.payload).toStrictEqual({ response: 'test ghi' });
+        expect(output.readableLength).toBe(0);
+    });
     test('fallible stream', async () => {
         const service = FallibleServiceConstructor();
         const [input, output] = asClientStream({}, service.procedures.echo);
@@ -85,4 +99,23 @@ describe('server-side test', () => {
         assert(streamResult2 && streamResult1.ok);
         expect(streamResult2.payload).toStrictEqual({ result: 3 });
     });
+    test('uploads', async () => {
+        const service = UploadableServiceConstructor();
+        const [input, result] = asClientUpload({}, service.procedures.addMultiple);
+        input.push({ n: 1 });
+        input.push({ n: 2 });
+        input.end();
+        expect(await result).toStrictEqual({ ok: true, payload: { result: 3 } });
+    });
+    test('uploads with initialization', async () => {
+        const service = UploadableServiceConstructor();
+        const [input, result] = asClientUploadWithInitialization({}, service.procedures.addMultipleWithPrefix, { prefix: 'test' });
+        input.push({ n: 1 });
+        input.push({ n: 2 });
+        input.end();
+        expect(await result).toStrictEqual({
+            ok: true,
+            payload: { result: 'test 3' },
+        });
+    });
 });

package/dist/__tests__/invariants.test.js

@@ -52,14 +52,14 @@ describe('procedures should leave no trace after finishing', async () => {
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        let serverListeners = serverTransport.messageHandlers.size;
-        let clientListeners = clientTransport.messageHandlers.size;
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
         // start procedure
         await client.test.add.rpc({ n: 3 });
         // end procedure
         // number of message handlers shouldn't increase after rpc
-        expect(serverTransport.messageHandlers.size).toEqual(serverListeners);
-        expect(clientTransport.messageHandlers.size).toEqual(clientListeners);
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
         // check number of connections
         expect(serverTransport.connections.size).toEqual(1);
         expect(clientTransport.connections.size).toEqual(1);
@@ -73,8 +73,8 @@ describe('procedures should leave no trace after finishing', async () => {
         const serviceDefs = { test: TestServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        let serverListeners = serverTransport.messageHandlers.size;
-        let clientListeners = clientTransport.messageHandlers.size;
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
         // start procedure
         const [input, output, close] = await client.test.echo.stream();
         input.push({ msg: '1', ignore: false });
@@ -93,8 +93,8 @@ describe('procedures should leave no trace after finishing', async () => {
         close();
         // end procedure
         // number of message handlers shouldn't increase after stream ends
-        expect(serverTransport.messageHandlers.size).toEqual(serverListeners);
-        expect(clientTransport.messageHandlers.size).toEqual(clientListeners);
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
         // check number of connections
         expect(serverTransport.connections.size).toEqual(1);
         expect(clientTransport.connections.size).toEqual(1);
@@ -108,8 +108,8 @@ describe('procedures should leave no trace after finishing', async () => {
         const serviceDefs = { test: SubscribableServiceConstructor() };
         const server = await createServer(serverTransport, serviceDefs);
         const client = createClient(clientTransport);
-        let serverListeners = serverTransport.messageHandlers.size;
-        let clientListeners = clientTransport.messageHandlers.size;
+        let serverListeners = serverTransport.eventDispatcher.numberOfListeners('message');
+        let clientListeners = clientTransport.eventDispatcher.numberOfListeners('message');
         // start procedure
         const [subscription, close] = await client.test.value.subscribe({});
         let result = await iterNext(subscription);
@@ -123,8 +123,8 @@ describe('procedures should leave no trace after finishing', async () => {
         close();
         // end procedure
         // number of message handlers shouldn't increase after stream ends
-        expect(serverTransport.messageHandlers.size).toEqual(serverListeners);
-        expect(clientTransport.messageHandlers.size).toEqual(clientListeners);
+        expect(serverTransport.eventDispatcher.numberOfListeners('message')).toEqual(serverListeners);
+        expect(clientTransport.eventDispatcher.numberOfListeners('message')).toEqual(clientListeners);
         // check number of connections
         expect(serverTransport.connections.size).toEqual(1);
         expect(clientTransport.connections.size).toEqual(1);

package/dist/__tests__/serialize.test.js

@@ -46,6 +46,45 @@ describe('serialize service to jsonschema', () => {
                     errors: { not: {} },
                     type: 'stream',
                 },
+                echoWithPrefix: {
+                    errors: {
+                        not: {},
+                    },
+                    init: {
+                        properties: {
+                            prefix: {
+                                type: 'string',
+                            },
+                        },
+                        required: ['prefix'],
+                        type: 'object',
+                    },
+                    input: {
+                        properties: {
+                            end: {
+                                type: 'boolean',
+                            },
+                            ignore: {
+                                type: 'boolean',
+                            },
+                            msg: {
+                                type: 'string',
+                            },
+                        },
+                        required: ['msg', 'ignore'],
+                        type: 'object',
+                    },
+                    output: {
+                        properties: {
+                            response: {
+                                type: 'string',
+                            },
+                        },
+                        required: ['response'],
+                        type: 'object',
+                    },
+                    type: 'stream',
+                },
             },
         });
     });