@replit/river 0.9.3 → 0.10.1

package/dist/{router/builder.d.ts → builder-3c4485f0.d.ts}

@@ -1,20 +1,73 @@
-import { TObject, Static, TUnion } from '@sinclair/typebox';
-import type { Pushable } from 'it-pushable';
-import { TransportMessage } from '../transport/message';
-import { ServiceContextWithState } from './context';
-import { Result, RiverError, RiverUncaughtSchema } from './result';
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TObject, TLiteralString, TString, TSchema, TUnion, TNever, Static } from '@sinclair/typebox';
+import { Pushable } from 'it-pushable';
+
+/**
+ * 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;
+ *   }
+ * }
+ * ```
+ */
+interface ServiceContext {
+    state: object | unknown;
+}
+/**
+ * The {@link ServiceContext} with state. This is what is passed to procedures.
+ */
+type ServiceContextWithState<State extends object | unknown> = ServiceContext & {
+    state: State;
+};
+
+type RiverErrorSchema = TObject<{
+    code: TLiteralString;
+    message: TLiteralString | TString;
+}> | TObject<{
+    code: TLiteralString;
+    message: TLiteralString | TString;
+    extras: TSchema;
+}>;
+type RiverError = TUnion<RiverErrorSchema[]> | RiverErrorSchema | TNever;
+declare const UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
+declare const RiverUncaughtSchema: TObject<{
+    code: TUnion<[_sinclair_typebox.TLiteral<"UNCAUGHT_ERROR">, _sinclair_typebox.TLiteral<"UNEXPECTED_DISCONNECT">]>;
+    message: TString;
+}>;
+type Result<T, E> = {
+    ok: true;
+    payload: T;
+} | {
+    ok: false;
+    payload: E;
+};
+declare function Ok<T, E>(payload: T): Result<T, E>;
+declare function Err<T, E>(error: E): Result<T, E>;
+
 /**
  * The valid {@link Procedure} types. The `stream` and `upload` types can optionally have a
  * different type for the very first initialization message. The suffixless types correspond to
  * gRPC's four combinations of stream / non-stream in each direction.
  */
-export type ValidProcType = 'rpc' | 'upload' | 'subscription' | 'stream';
+type ValidProcType = 'rpc' | 'upload' | 'subscription' | 'stream';
 /**
  * A generic procedure listing where the keys are the names of the procedures
  * and the values are the {@link Procedure} definitions. This is not meant to
  * be constructed directly, use the {@link ServiceBuilder} class instead.
  */
-export type ProcListing = Record<string, AnyProcedure>;
+type ProcListing = Record<string, AnyProcedure>;
 /**
  * Represents a service with a name, state, and procedures.
  * This is not meant to be constructed directly, use the {@link ServiceBuilder} class instead.
@@ -22,30 +75,30 @@ export type ProcListing = Record<string, AnyProcedure>;
  * @template State The type of the service state.
  * @template Procs The type of the service procedures.
  */
-export interface Service<Name extends string, State extends object, Procs extends ProcListing> {
+interface Service<Name extends string, State extends object, Procs extends ProcListing> {
     name: Name;
     state: State;
     procedures: Procs;
 }
-export type AnyService = Service<string, object, any>;
+type AnyService = Service<string, object, any>;
 /**
  * Serializes a service object into its corresponding JSON Schema Draft 7 type.
  * @param {AnyService} s - The service object to serialize.
  * @returns A plain object representing the serialized service.
  */
-export declare function serializeService(s: AnyService): object;
+declare function serializeService(s: AnyService): object;
 /**
  * Helper to get the type definition for a specific handler of a procedure in a service.
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
+type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
 /**
  * Helper to get whether the type definition for the procedure contains an init type.
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcHasInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
+type ProcHasInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
     init: any;
 } ? true : false;
 /**
@@ -53,32 +106,32 @@ export type ProcHasInit<S extends AnyService, ProcName extends keyof S['procedur
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['init'];
+type ProcInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['init'];
 /**
  * Helper to get the type definition for the procedure input of a service.
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcInput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['input'];
+type ProcInput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['input'];
 /**
  * Helper to get the type definition for the procedure output of a service.
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcOutput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['output'];
+type ProcOutput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['output'];
 /**
  * Helper to get the type definition for the procedure errors of a service.
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcErrors<S extends AnyService, ProcName extends keyof S['procedures']> = TUnion<[S['procedures'][ProcName]['errors'], typeof RiverUncaughtSchema]>;
+type ProcErrors<S extends AnyService, ProcName extends keyof S['procedures']> = TUnion<[S['procedures'][ProcName]['errors'], typeof RiverUncaughtSchema]>;
 /**
  * Helper to get the type of procedure in a service.
  * @template S - The service.
  * @template ProcName - The name of the procedure.
  */
-export type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
-export type PayloadType = TObject | TUnion<TObject[]>;
+type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
+type PayloadType = TObject | TUnion<TObject[]>;
 /**
  * Defines a Procedure type that can be either an RPC or a stream procedure.
  * @template State - The TypeBox schema of the state object.
@@ -87,52 +140,52 @@ export type PayloadType = TObject | TUnion<TObject[]>;
  * @template O - The TypeBox schema of the output object.
  * @template Init - The TypeBox schema of the input initialization object.
  */
-export type Procedure<State extends object | unknown, Ty extends ValidProcType, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null> = Ty extends 'rpc' ? Init extends null ? {
+type Procedure<State extends object | unknown, Ty extends ValidProcType, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null> = Ty extends 'rpc' ? Init extends null ? {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: TransportMessage<Static<I>>) => Promise<TransportMessage<Result<Static<O>, Static<E>>>>;
+    handler: (context: ServiceContextWithState<State>, input: Static<I>) => Promise<Result<Static<O>, Static<E>>>;
     type: Ty;
 } : never : Ty extends 'upload' ? Init extends PayloadType ? {
     init: Init;
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, init: TransportMessage<Static<Init>>, input: AsyncIterable<TransportMessage<Static<I>>>) => Promise<TransportMessage<Result<Static<O>, Static<E>>>>;
+    handler: (context: ServiceContextWithState<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>) => Promise<Result<Static<O>, Static<E>>>;
     type: Ty;
 } : {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: AsyncIterable<TransportMessage<Static<I>>>) => Promise<TransportMessage<Result<Static<O>, Static<E>>>>;
+    handler: (context: ServiceContextWithState<State>, input: AsyncIterableIterator<Static<I>>) => Promise<Result<Static<O>, Static<E>>>;
     type: Ty;
 } : Ty extends 'subscription' ? Init extends null ? {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: TransportMessage<Static<I>>, output: Pushable<TransportMessage<Result<Static<O>, Static<E>>>>) => Promise<void>;
+    handler: (context: ServiceContextWithState<State>, input: Static<I>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
     type: Ty;
 } : never : Ty extends 'stream' ? Init extends PayloadType ? {
     init: Init;
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, init: TransportMessage<Static<Init>>, input: AsyncIterable<TransportMessage<Static<I>>>, output: Pushable<TransportMessage<Result<Static<O>, Static<E>>>>) => Promise<void>;
+    handler: (context: ServiceContextWithState<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
     type: Ty;
 } : {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: AsyncIterable<TransportMessage<Static<I>>>, output: Pushable<TransportMessage<Result<Static<O>, Static<E>>>>) => Promise<void>;
+    handler: (context: ServiceContextWithState<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
     type: Ty;
 } : never;
-export type AnyProcedure = Procedure<object, ValidProcType, PayloadType, PayloadType, RiverError, PayloadType | null>;
+type AnyProcedure = Procedure<object, ValidProcType, PayloadType, PayloadType, RiverError, PayloadType | null>;
 /**
  * A builder class for creating River Services.
  * You must call the finalize method to get the finalized schema for use in a service router.
  * @template T The type of the service.
  */
-export declare class ServiceBuilder<T extends Service<string, object, ProcListing>> {
+declare class ServiceBuilder<T extends Service<string, object, ProcListing>> {
     private readonly schema;
     private constructor();
     /**
@@ -175,4 +228,5 @@ export declare class ServiceBuilder<T extends Service<string, object, ProcListin
         procedures: {};
     }>;
 }
-//# sourceMappingURL=builder.d.ts.map
+
+export { AnyService as A, Err as E, Ok as O, PayloadType as P, RiverError as R, ServiceContext as S, UNCAUGHT_ERROR as U, ValidProcType as V, Procedure as a, Result as b, RiverUncaughtSchema as c, AnyProcedure as d, ProcType as e, ProcInput as f, ProcOutput as g, ProcErrors as h, ProcHasInit as i, ProcInit as j, ServiceBuilder as k, ProcListing as l, Service as m, ProcHandler as n, ServiceContextWithState as o, RiverErrorSchema as p, serializeService as s };