@replit/river 0.9.3 → 0.10.1

package/dist/__tests__/invariants.test.js

@@ -1,138 +0,0 @@
-import { afterAll, assert, describe, expect, test } from 'vitest';
-import http from 'http';
-import { createWebSocketServer, createWsTransports, iterNext, onServerReady, } from '../util/testHelpers';
-import { SubscribableServiceConstructor, TestServiceConstructor, } from './fixtures/services';
-import { createClient, createServer } from '../router';
-import { ensureServerIsClean, ensureTransportQueuesAreEventuallyEmpty, waitUntil, } from './fixtures/cleanup';
-describe('procedures should leave no trace after finishing', async () => {
-    const httpServer = http.createServer();
-    const port = await onServerReady(httpServer);
-    const webSocketServer = await createWebSocketServer(httpServer);
-    const getTransports = () => createWsTransports(port, webSocketServer);
-    afterAll(() => {
-        webSocketServer.close();
-        httpServer.close();
-    });
-    test('closing a transport from the client cleans up connection on the server', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        expect(clientTransport.connections.size).toEqual(0);
-        expect(serverTransport.connections.size).toEqual(0);
-        // start procedure
-        await client.test.add.rpc({ n: 3 });
-        // end procedure
-        expect(clientTransport.connections.size).toEqual(1);
-        expect(serverTransport.connections.size).toEqual(1);
-        // should be back to 0 connections after client closes
-        clientTransport.close();
-        expect(clientTransport.connections.size).toEqual(0);
-        await waitUntil(() => serverTransport.connections.size, 0, 'server should cleanup connection after client closes');
-    });
-    test('closing a transport from the server cleans up connection on the client', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        expect(clientTransport.connections.size).toEqual(0);
-        expect(serverTransport.connections.size).toEqual(0);
-        // start procedure
-        await client.test.add.rpc({ n: 3 });
-        // end procedure
-        expect(clientTransport.connections.size).toEqual(1);
-        expect(serverTransport.connections.size).toEqual(1);
-        // should be back to 0 connections after client closes
-        serverTransport.close();
-        expect(serverTransport.connections.size).toEqual(0);
-        await waitUntil(() => clientTransport.connections.size, 0, 'client should cleanup connection after server closes');
-    });
-    test('rpc', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        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.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);
-        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
-        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
-        // ensure we have no streams left on the server
-        await ensureServerIsClean(server);
-    });
-    test('stream', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        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 });
-        input.push({ msg: '2', ignore: false, end: true });
-        const result1 = await iterNext(output);
-        assert(result1.ok);
-        expect(result1.payload).toStrictEqual({ response: '1' });
-        // ensure we only have one stream despite pushing multiple messages.
-        await waitUntil(() => server.streams.size, 1);
-        input.end();
-        // ensure we no longer have any streams since the input was closed.
-        await waitUntil(() => server.streams.size, 0);
-        const result2 = await iterNext(output);
-        assert(result2.ok);
-        expect(result2.payload).toStrictEqual({ response: '2' });
-        const result3 = await output.next();
-        assert(result3.done);
-        close();
-        // end procedure
-        // number of message handlers shouldn't increase after stream ends
-        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);
-        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
-        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
-        // ensure we have no streams left on the server
-        await ensureServerIsClean(server);
-    });
-    test('subscription', async () => {
-        const [clientTransport, serverTransport] = getTransports();
-        const serviceDefs = { test: SubscribableServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        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);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 0 });
-        const add1 = await client.test.add.rpc({ n: 1 });
-        assert(add1.ok);
-        result = await iterNext(subscription);
-        assert(result.ok);
-        expect(result.payload).toStrictEqual({ result: 1 });
-        close();
-        // end procedure
-        // number of message handlers shouldn't increase after stream ends
-        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);
-        await ensureTransportQueuesAreEventuallyEmpty(clientTransport);
-        await ensureTransportQueuesAreEventuallyEmpty(serverTransport);
-        // ensure we have no streams left on the server
-        await ensureServerIsClean(server);
-    });
-});

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

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

package/dist/__tests__/serialize.test.d.ts.map

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

package/dist/__tests__/serialize.test.js

@@ -1,208 +0,0 @@
-import { expect, describe, test } from 'vitest';
-import { serializeService } from '../router/builder';
-import { BinaryFileServiceConstructor, FallibleServiceConstructor, TestServiceConstructor, } from './fixtures/services';
-describe('serialize service to jsonschema', () => {
-    test('serialize basic service', () => {
-        const service = TestServiceConstructor();
-        expect(serializeService(service)).toStrictEqual({
-            name: 'test',
-            state: { count: 0 },
-            procedures: {
-                add: {
-                    input: {
-                        properties: {
-                            n: { type: 'number' },
-                        },
-                        required: ['n'],
-                        type: 'object',
-                    },
-                    output: {
-                        properties: {
-                            result: { type: 'number' },
-                        },
-                        required: ['result'],
-                        type: 'object',
-                    },
-                    errors: { not: {} },
-                    type: 'rpc',
-                },
-                echo: {
-                    input: {
-                        properties: {
-                            msg: { type: 'string' },
-                            ignore: { type: 'boolean' },
-                            end: { type: 'boolean' },
-                        },
-                        required: ['msg', 'ignore'],
-                        type: 'object',
-                    },
-                    output: {
-                        properties: {
-                            response: { type: 'string' },
-                        },
-                        required: ['response'],
-                        type: 'object',
-                    },
-                    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',
-                },
-            },
-        });
-    });
-    test('serialize service with binary', () => {
-        const service = BinaryFileServiceConstructor();
-        expect(serializeService(service)).toStrictEqual({
-            name: 'bin',
-            procedures: {
-                getFile: {
-                    errors: {
-                        not: {},
-                    },
-                    input: {
-                        properties: {
-                            file: {
-                                type: 'string',
-                            },
-                        },
-                        required: ['file'],
-                        type: 'object',
-                    },
-                    output: {
-                        properties: {
-                            contents: {
-                                type: 'Uint8Array',
-                            },
-                        },
-                        required: ['contents'],
-                        type: 'object',
-                    },
-                    type: 'rpc',
-                },
-            },
-            state: {},
-        });
-    });
-    test('serialize service with errors', () => {
-        const service = FallibleServiceConstructor();
-        expect(serializeService(service)).toStrictEqual({
-            name: 'fallible',
-            state: {},
-            procedures: {
-                divide: {
-                    input: {
-                        properties: {
-                            a: { type: 'number' },
-                            b: { type: 'number' },
-                        },
-                        required: ['a', 'b'],
-                        type: 'object',
-                    },
-                    output: {
-                        properties: {
-                            result: { type: 'number' },
-                        },
-                        required: ['result'],
-                        type: 'object',
-                    },
-                    errors: {
-                        properties: {
-                            code: { const: 'DIV_BY_ZERO', type: 'string' },
-                            message: { type: 'string' },
-                            extras: {
-                                properties: {
-                                    test: {
-                                        type: 'string',
-                                    },
-                                },
-                                required: ['test'],
-                                type: 'object',
-                            },
-                        },
-                        required: ['code', 'message', 'extras'],
-                        type: 'object',
-                    },
-                    type: 'rpc',
-                },
-                echo: {
-                    errors: {
-                        properties: {
-                            code: {
-                                const: 'STREAM_ERROR',
-                                type: 'string',
-                            },
-                            message: {
-                                type: 'string',
-                            },
-                        },
-                        required: ['code', 'message'],
-                        type: 'object',
-                    },
-                    input: {
-                        properties: {
-                            msg: {
-                                type: 'string',
-                            },
-                            throwError: {
-                                type: 'boolean',
-                            },
-                            throwResult: {
-                                type: 'boolean',
-                            },
-                        },
-                        required: ['msg', 'throwResult', 'throwError'],
-                        type: 'object',
-                    },
-                    output: {
-                        properties: {
-                            response: {
-                                type: 'string',
-                            },
-                        },
-                        required: ['response'],
-                        type: 'object',
-                    },
-                    type: 'stream',
-                },
-            },
-        });
-    });
-});