@replit/river 0.1.7 → 0.1.9

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

@@ -18,9 +18,9 @@ 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;
@@ -36,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/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,6 +1,7 @@
 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, State extends object, Procs extends ProcListing> {
@@ -17,12 +18,12 @@ export type ProcType<S extends AnyService, ProcName extends keyof S['procedures'
 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>> {

package/dist/router/client.d.ts

@@ -6,7 +6,7 @@ import { Static } from '@sinclair/typebox';
 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>>>,
+        AsyncIterableIterator<Static<ProcOutput<Router, ProcName>>>,
         () => void
     ]>;
 };

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 { AnyService } from './builder';
+import { ServiceContext } from './context';
 export interface Server<Services> {
     services: Services;
     close(): Promise<void>;
 }
-export declare function createServer<Services extends Record<string, AnyService>>(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.7",
+  "version": "0.1.9",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",