@replit/river 0.1.6 → 0.1.8

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

@@ -18,15 +18,16 @@ export declare const TestServiceConstructor: () => {
             output: import("@sinclair/typebox").TObject<{
                 result: import("@sinclair/typebox").TNumber;
             }>;
-            handler: (state: {
+            handler: (context: import("..").ServiceContextWithState<{
                 count: number;
-            }, input: import("../transport/message").TransportMessage<{
+            }>, input: import("../transport/message").TransportMessage<{
                 n: number;
             }>) => Promise<import("../transport/message").TransportMessage<{
                 result: number;
             }>>;
             type: "rpc";
         };
+    } & {
         echo: {
             input: import("@sinclair/typebox").TObject<{
                 msg: import("@sinclair/typebox").TString;
@@ -35,9 +36,9 @@ export declare const TestServiceConstructor: () => {
             output: import("@sinclair/typebox").TObject<{
                 response: import("@sinclair/typebox").TString;
             }>;
-            handler: (state: {
+            handler: (context: import("..").ServiceContextWithState<{
                 count: number;
-            }, input: AsyncIterable<import("../transport/message").TransportMessage<{
+            }>, input: AsyncIterable<import("../transport/message").TransportMessage<{
                 msg: string;
                 ignore: boolean;
             }>>, output: import("it-pushable").Pushable<import("../transport/message").TransportMessage<{

package/dist/__tests__/integration.test.js

@@ -20,17 +20,17 @@ export const TestServiceConstructor = () => ServiceBuilder.create('test')
     type: 'rpc',
     input: Type.Object({ n: Type.Number() }),
     output: Type.Object({ result: Type.Number() }),
-    async handler(state, msg) {
+    async handler(ctx, msg) {
         const { n } = msg.payload;
-        state.count += n;
-        return reply(msg, { result: state.count });
+        ctx.state.count += n;
+        return reply(msg, { result: ctx.state.count });
     },
 })
     .defineProcedure('echo', {
     type: 'stream',
     input: EchoRequest,
     output: EchoResponse,
-    async handler(_state, msgStream, returnStream) {
+    async handler(_ctx, msgStream, returnStream) {
         for await (const msg of msgStream) {
             const req = msg.payload;
             if (!req.ignore) {

package/dist/__tests__/typescript-stress.test.d.ts

@@ -0,0 +1,7 @@
+import { MessageId, OpaqueTransportMessage } from '../transport/message';
+import { Transport } from '../transport/types';
+export declare class MockTransport extends Transport {
+    constructor(clientId: string);
+    send(msg: OpaqueTransportMessage): MessageId;
+    close(): Promise<void>;
+}

package/dist/__tests__/typescript-stress.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, test } from 'vitest';
+import { ServiceBuilder, serializeService } from '../router/builder';
+import { Type } from '@sinclair/typebox';
+import { reply } from '../transport/message';
+import { createServer } from '../router/server';
+import { Transport } from '../transport/types';
+import { NaiveJsonCodec } from '../codec/json';
+import { createClient } from '../router/client';
+const fnBody = {
+    type: 'rpc',
+    input: Type.Object({ a: Type.Number() }),
+    output: Type.Object({ b: Type.Number() }),
+    async handler(_state, msg) {
+        return reply(msg, { b: msg.payload.a });
+    },
+};
+// typescript is limited to max 50 constraints
+// see: https://github.com/microsoft/TypeScript/issues/33541
+const svc = () => ServiceBuilder.create('test')
+    .defineProcedure('f1', fnBody)
+    .defineProcedure('f2', fnBody)
+    .defineProcedure('f3', fnBody)
+    .defineProcedure('f4', fnBody)
+    .defineProcedure('f5', fnBody)
+    .defineProcedure('f6', fnBody)
+    .defineProcedure('f7', fnBody)
+    .defineProcedure('f8', fnBody)
+    .defineProcedure('f9', fnBody)
+    .defineProcedure('f10', fnBody)
+    .defineProcedure('f11', fnBody)
+    .defineProcedure('f12', fnBody)
+    .defineProcedure('f13', fnBody)
+    .defineProcedure('f14', fnBody)
+    .defineProcedure('f15', fnBody)
+    .defineProcedure('f16', fnBody)
+    .defineProcedure('f17', fnBody)
+    .defineProcedure('f18', fnBody)
+    .defineProcedure('f19', fnBody)
+    .defineProcedure('f20', fnBody)
+    .defineProcedure('f21', fnBody)
+    .defineProcedure('f22', fnBody)
+    .defineProcedure('f23', fnBody)
+    .defineProcedure('f24', fnBody)
+    .defineProcedure('f25', fnBody)
+    .defineProcedure('f26', fnBody)
+    .defineProcedure('f27', fnBody)
+    .defineProcedure('f28', fnBody)
+    .defineProcedure('f29', fnBody)
+    .defineProcedure('f30', fnBody)
+    .defineProcedure('f31', fnBody)
+    .defineProcedure('f32', fnBody)
+    .defineProcedure('f33', fnBody)
+    .defineProcedure('f34', fnBody)
+    .defineProcedure('f35', fnBody)
+    .defineProcedure('f36', fnBody)
+    .defineProcedure('f37', fnBody)
+    .defineProcedure('f38', fnBody)
+    .defineProcedure('f39', fnBody)
+    .defineProcedure('f40', fnBody)
+    .defineProcedure('f41', fnBody)
+    .defineProcedure('f42', fnBody)
+    .defineProcedure('f43', fnBody)
+    .defineProcedure('f44', fnBody)
+    .defineProcedure('f45', fnBody)
+    .defineProcedure('f46', fnBody)
+    .defineProcedure('f47', fnBody)
+    .defineProcedure('f48', fnBody)
+    .defineProcedure('f49', fnBody)
+    .finalize();
+// mock transport
+export class MockTransport extends Transport {
+    constructor(clientId) {
+        super(NaiveJsonCodec, clientId);
+    }
+    send(msg) {
+        const id = msg.id;
+        return id;
+    }
+    async close() { }
+}
+describe("ensure typescript doesn't give up trying to infer the types for large services", () => {
+    test('service with many procedures hits typescript limit', () => {
+        expect(serializeService(svc())).toBeTruthy();
+    });
+    test('serverclient should support many services with many procedures', async () => {
+        const listing = {
+            a: svc(),
+            b: svc(),
+            c: svc(),
+            d: svc(),
+        };
+        const server = await createServer(new MockTransport('SERVER'), listing);
+        const client = createClient(new MockTransport('client'));
+        expect(server).toBeTruthy();
+        expect(client).toBeTruthy();
+    });
+});

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export type { ServerClient } from './router/client';
 export { createServer } from './router/server';
 export { asClientRpc, asClientStream } from './router/server.util';
 export type { Server } from './router/server';
+export type { ServiceContext, ServiceContextWithState } from './router/context';
 export { Transport } from './transport/types';
 export { TransportMessageSchema, OpaqueTransportMessageSchema, TransportAckSchema, msg, payloadToTransportMessage, ack, reply, } from './transport/message';
 export type { TransportMessage, MessageId, OpaqueTransportMessage, TransportClientId, TransportMessageAck, } from './transport/message';

package/dist/router/builder.d.ts

@@ -1,27 +1,29 @@
 import { TObject, Static } from '@sinclair/typebox';
 import type { Pushable } from 'it-pushable';
 import { TransportMessage } from '../transport/message';
+import { ServiceContextWithState } from './context';
 export type ValidProcType = 'stream' | 'rpc';
 export type ProcListing = Record<string, Procedure<object, ValidProcType, TObject, TObject>>;
-export interface Service<Name extends string = string, State extends object = object, Procs extends ProcListing = Record<string, any>> {
+export interface Service<Name extends string, State extends object, Procs extends ProcListing> {
     name: Name;
     state: State;
     procedures: Procs;
 }
-export declare function serializeService(s: Service): object;
-export type ProcHandler<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
-export type ProcInput<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['input'];
-export type ProcOutput<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['output'];
-export type ProcType<S extends Service, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
+export type AnyService = Service<string, object, any>;
+export declare function serializeService(s: AnyService): object;
+export type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
+export type ProcInput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['input'];
+export type ProcOutput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['output'];
+export type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
 export type Procedure<State extends object | unknown, Ty extends ValidProcType, I extends TObject, O extends TObject> = Ty extends 'rpc' ? {
     input: I;
     output: O;
-    handler: (state: State, input: TransportMessage<Static<I>>) => Promise<TransportMessage<Static<O>>>;
+    handler: (context: ServiceContextWithState<State>, input: TransportMessage<Static<I>>) => Promise<TransportMessage<Static<O>>>;
     type: Ty;
 } : {
     input: I;
     output: O;
-    handler: (state: State, input: AsyncIterable<TransportMessage<Static<I>>>, output: Pushable<TransportMessage<Static<O>>>) => Promise<void>;
+    handler: (context: ServiceContextWithState<State>, input: AsyncIterable<TransportMessage<Static<I>>>, output: Pushable<TransportMessage<Static<O>>>) => Promise<void>;
     type: Ty;
 };
 export declare class ServiceBuilder<T extends Service<string, object, ProcListing>> {
@@ -33,13 +35,11 @@ export declare class ServiceBuilder<T extends Service<string, object, ProcListin
         state: InitState;
         procedures: T['procedures'];
     }>;
-    defineProcedure<ProcName extends string, Ty extends ValidProcType, I extends TObject, O extends TObject, ProcEntry = {
-        [k in ProcName]: Procedure<T['state'], Ty, I, O>;
-    }>(procName: ProcName, procDef: Procedure<T['state'], Ty, I, O>): ServiceBuilder<{
+    defineProcedure<ProcName extends string, Ty extends ValidProcType, I extends TObject, O extends TObject>(procName: ProcName, procDef: Procedure<T['state'], Ty, I, O>): ServiceBuilder<{
         name: T['name'];
         state: T['state'];
-        procedures: {
-            [Key in keyof (T['procedures'] & ProcEntry)]: (T['procedures'] & ProcEntry)[Key];
+        procedures: T['procedures'] & {
+            [k in ProcName]: Procedure<T['state'], Ty, I, O>;
         };
     }>;
     static create<Name extends string>(name: Name): ServiceBuilder<{

package/dist/router/client.d.ts

@@ -1,17 +1,17 @@
 import { Transport } from '../transport/types';
-import { ProcInput, ProcOutput, ProcType, Service } from './builder';
+import { AnyService, ProcInput, ProcOutput, ProcType } from './builder';
 import type { Pushable } from 'it-pushable';
 import { Server } from './server';
 import { Static } from '@sinclair/typebox';
-type ServiceClient<Router extends Service> = {
+type ServiceClient<Router extends AnyService> = {
     [ProcName in keyof Router['procedures']]: ProcType<Router, ProcName> extends 'rpc' ? (input: Static<ProcInput<Router, ProcName>>) => Promise<Static<ProcOutput<Router, ProcName>>> : () => Promise<[
         Pushable<Static<ProcInput<Router, ProcName>>>,
         AsyncIterator<Static<ProcOutput<Router, ProcName>>>,
         () => void
     ]>;
 };
-export type ServerClient<Srv extends Server<Record<string, Service>>> = {
+export type ServerClient<Srv extends Server<Record<string, AnyService>>> = {
     [SvcName in keyof Srv['services']]: ServiceClient<Srv['services'][SvcName]>;
 };
-export declare const createClient: <Srv extends Server<Record<string, Service<string, object, Record<string, any>>>>>(transport: Transport) => ServerClient<Srv>;
+export declare const createClient: <Srv extends Server<Record<string, AnyService>>>(transport: Transport) => ServerClient<Srv>;
 export {};

package/dist/router/context.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The context for services/procedures. This is used only on
+ * the server.
+ *
+ * An important detail is that the state prop is always on
+ * this interface and it shouldn't be changed, removed, or
+ * extended. This prop is for the state of a service.
+ *
+ * You should use declaration merging to extend this interface
+ * with whatever you need. For example, if you need to access
+ * a database, you could do:
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ServiceContext {
+ *     db: Database;
+ *   }
+ * }
+ * ```
+ */
+export interface ServiceContext {
+    state: object | unknown;
+}
+/**
+ * The {@link ServiceContext} with state. This is what is passed to procedures.
+ */
+export type ServiceContextWithState<State extends object | unknown> = ServiceContext & {
+    state: State;
+};

package/dist/router/context.js

@@ -0,0 +1 @@
+export {};

package/dist/router/server.d.ts

@@ -1,7 +1,8 @@
 import { Transport } from '../transport/types';
-import { Service } from './builder';
+import { AnyService } from './builder';
+import { ServiceContext } from './context';
 export interface Server<Services> {
     services: Services;
     close(): Promise<void>;
 }
-export declare function createServer<Services extends Record<string, Service>>(transport: Transport, services: Services): Promise<Server<Services>>;
+export declare function createServer<Services extends Record<string, AnyService>>(transport: Transport, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Promise<Server<Services>>;

package/dist/router/server.js

@@ -1,9 +1,19 @@
 import { Value } from '@sinclair/typebox/value';
 import { pushable } from 'it-pushable';
-export async function createServer(transport, services) {
-    // create streams for every stream procedure
+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}`);
+        }
+        return context;
+    }
     for (const [serviceName, service] of Object.entries(services)) {
+        // populate the context map
+        contextMap.set(service, { ...extendedContext, state: service.state });
+        // create streams for every stream procedure
         for (const [procedureName, proc] of Object.entries(service.procedures)) {
             const procedure = proc;
             if (procedure.type === 'stream') {
@@ -14,7 +24,7 @@ export async function createServer(transport, services) {
                     outgoing,
                     doneCtx: Promise.all([
                         // processing the actual procedure
-                        procedure.handler(service.state, incoming, outgoing),
+                        procedure.handler(getContext(service), incoming, outgoing),
                         // sending outgoing messages back to client
                         (async () => {
                             for await (const response of outgoing) {
@@ -39,8 +49,7 @@ export async function createServer(transport, services) {
                 const inputMessage = msg;
                 if (procedure.type === 'rpc' &&
                     Value.Check(procedure.input, inputMessage.payload)) {
-                    // synchronous rpc
-                    const response = await procedure.handler(service.state, inputMessage);
+                    const response = await procedure.handler(getContext(service), inputMessage);
                     transport.send(response);
                     return;
                 }

package/dist/router/server.util.d.ts

@@ -1,5 +1,6 @@
 import { Static, TObject } from '@sinclair/typebox';
 import { Procedure } from './builder';
 import type { Pushable } from 'it-pushable';
-export declare function asClientRpc<State extends object | unknown, I extends TObject, O extends TObject>(state: State, proc: Procedure<State, 'rpc', I, O>): (msg: Static<I>) => Promise<Static<O>>;
-export declare function asClientStream<State extends object | unknown, I extends TObject, O extends TObject>(state: State, proc: Procedure<State, 'stream', I, O>): [Pushable<Static<I>>, Pushable<Static<O>>];
+import { ServiceContext } from './context';
+export declare function asClientRpc<State extends object | unknown, I extends TObject, O extends TObject>(state: State, proc: Procedure<State, 'rpc', I, O>, extendedContext?: Omit<ServiceContext, 'state'>): (msg: Static<I>) => Promise<Static<O>>;
+export declare function asClientStream<State extends object | unknown, I extends TObject, O extends TObject>(state: State, proc: Procedure<State, 'stream', I, O>, extendedContext?: Omit<ServiceContext, 'state'>): [Pushable<Static<I>>, Pushable<Static<O>>];

package/dist/router/server.util.js

@@ -1,11 +1,11 @@
 import { payloadToTransportMessage, } from '../transport/message';
 import { pushable } from 'it-pushable';
-export function asClientRpc(state, proc) {
+export function asClientRpc(state, proc, extendedContext) {
     return (msg) => proc
-        .handler(state, payloadToTransportMessage(msg))
+        .handler({ ...extendedContext, state }, payloadToTransportMessage(msg))
         .then((res) => res.payload);
 }
-export function asClientStream(state, proc) {
+export function asClientStream(state, proc, extendedContext) {
     const i = pushable({ objectMode: true });
     const o = pushable({ objectMode: true });
     const ri = pushable({ objectMode: true });
@@ -25,7 +25,7 @@ export function asClientStream(state, proc) {
     })();
     // handle
     (async () => {
-        await proc.handler(state, ri, ro);
+        await proc.handler({ ...extendedContext, state }, ri, ro);
         ro.end();
     })();
     return [i, o];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@replit/river",
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",