@replit/river 0.18.5 → 0.19.2

package/dist/router/index.d.ts

@@ -1,387 +1,11 @@
-import { TUnion, Static } from '@sinclair/typebox';
-import { e as ProcedureMap, P as PayloadType, c as RiverUncaughtSchema, U as Unbranded, B as Branded, A as AnyProcedure, R as RiverError, b as Result, S as ServiceContext } from '../procedures-bfffcb0b.js';
-export { E as Err, O as Ok, a as Procedure, d as ProcedureResult, f as RPCProcedure, m as RiverErrorSchema, j as ServiceContextWithState, k as ServiceContextWithTransportInfo, i as StreamProcedure, h as SubscriptionProcedure, l as UNCAUGHT_ERROR, g as UploadProcedure, V as ValidProcType } from '../procedures-bfffcb0b.js';
-import { b as ClientTransport, C as Connection, c as ServerTransport } from '../index-d412ca83.js';
+import { A as AnyServiceSchemaMap, I as InstantiatedServiceSchemaMap, P as PayloadType, b as Result, R as RiverError, S as ServiceContext } from '../services-5fc5712d.js';
+export { C as Client, E as Err, O as Ok, B as Output, k as ProcErrors, g as ProcHandler, h as ProcInit, i as ProcInput, j as ProcOutput, l as ProcType, a as Procedure, o as ProcedureMap, d as ProcedureResult, p as RPCProcedure, z as ResultUnwrapErr, y as ResultUnwrapOk, x as RiverErrorSchema, c as RiverUncaughtSchema, n as SerializedServerSchema, e as Service, f as ServiceConfiguration, u as ServiceContextWithState, v as ServiceContextWithTransportInfo, m as ServiceSchema, r as StreamProcedure, q as SubscriptionProcedure, w as UNCAUGHT_ERROR, U as UploadProcedure, V as ValidProcType, t as createClient, s as serializeSchema } from '../services-5fc5712d.js';
+import { Static } from '@sinclair/typebox';
+import { ServerTransport } from '../transport/index.js';
 import { Pushable } from 'it-pushable';
-import { T as TransportClientId } from '../index-46ed19d8.js';
+import { C as Connection } from '../index-e2513701.js';
 import '../types-3e5768ec.js';
 
-/**
- * An instantiated service, probably from a {@link ServiceSchema}.
- *
- * You shouldn't construct these directly, use {@link ServiceSchema} instead.
- */
-interface Service<State extends object, Procs extends ProcedureMap<State>> {
-    readonly state: State;
-    readonly procedures: Procs;
-}
-/**
- * Represents any {@link Service} object.
- */
-type AnyService = Service<object, ProcedureMap>;
-/**
- * Represents any {@link ServiceSchema} object.
- */
-type AnyServiceSchema = ServiceSchema<object, ProcedureMap>;
-/**
- * A dictionary of {@link ServiceSchema}s, where the key is the service name.
- */
-type AnyServiceSchemaMap = Record<string, AnyServiceSchema>;
-/**
- * Takes a {@link AnyServiceSchemaMap} and returns a dictionary of instantiated
- * services.
- */
-type InstantiatedServiceSchemaMap<T extends AnyServiceSchemaMap> = {
-    [K in keyof T]: T[K] extends ServiceSchema<infer S, infer P> ? Service<S, P> : never;
-};
-/**
- * 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.
- */
-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.
- */
-type ProcHasInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
-    init: PayloadType;
-} ? true : false;
-/**
- * Helper to get the type definition for the procedure init type of a service.
- * @template S - The service.
- * @template ProcName - The name of the procedure.
- */
-type ProcInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
-    init: PayloadType;
-} ? S['procedures'][ProcName]['init'] : never;
-/**
- * Helper to get the type definition for the procedure input of a service.
- * @template S - The service.
- * @template ProcName - The name of the procedure.
- */
-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.
- */
-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.
- */
-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.
- */
-type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
-/**
- * A list of procedures where every procedure is "branded", as-in the procedure
- * was created via the {@link Procedure} constructors.
- */
-type BrandedProcedureMap<State> = Record<string, Branded<AnyProcedure<State>>>;
-/**
- * The configuration for a service.
- */
-interface ServiceConfiguration<State extends object> {
-    /**
-     * A factory function for creating a fresh state.
-     */
-    initializeState: () => State;
-}
-interface SerializedServiceSchema {
-    procedures: Record<string, {
-        input: PayloadType;
-        output: PayloadType;
-        errors?: RiverError;
-        type: 'rpc' | 'subscription' | 'upload' | 'stream';
-        init?: PayloadType;
-    }>;
-}
-type SerializedServerSchema = Record<string, SerializedServiceSchema>;
-declare function serializeSchema(services: AnyServiceSchemaMap): SerializedServerSchema;
-/**
- * The schema for a {@link Service}. This is used to define a service, specifically
- * its initial state and procedures.
- *
- * There are two ways to define a service:
- * 1. the {@link ServiceSchema.define} static method, which takes a configuration and
- *    a list of procedures directly. Use this to ergonomically define a service schema
- *    in one go. Good for smaller services, especially if they're stateless.
- * 2. the {@link ServiceSchema.scaffold} static method, which creates a scaffold that
- *    can be used to define procedures separately from the configuration. Use this to
- *    better organize your service's definition, especially if it's a large service.
- *    You can also use it in a builder pattern to define the service in a more
- *    fluent way.
- *
- * See the static methods for more information and examples.
- *
- * When defining procedures, use the {@link Procedure} constructors to create them.
- */
-declare class ServiceSchema<State extends object, Procedures extends ProcedureMap<State>> {
-    /**
-     * Factory function for creating a fresh state.
-     */
-    protected readonly initializeState: () => State;
-    /**
-     * The procedures for this service.
-     */
-    readonly procedures: Procedures;
-    /**
-     * @param config - The configuration for this service.
-     * @param procedures - The procedures for this service.
-     */
-    protected constructor(config: ServiceConfiguration<State>, procedures: Procedures);
-    /**
-     * Creates a {@link ServiceScaffold}, which can be used to define procedures
-     * that can then be merged into a {@link ServiceSchema}, via the scaffold's
-     * `finalize` method.
-     *
-     * There are two patterns that work well with this method. The first is using
-     * it to separate the definition of procedures from the definition of the
-     * service's configuration:
-     * ```ts
-     * const MyServiceScaffold = ServiceSchema.scaffold({
-     *   initializeState: () => ({ count: 0 }),
-     * });
-     *
-     * const incrementProcedures = MyServiceScaffold.procedures({
-     *   increment: Procedure.rpc({
-     *     input: Type.Object({ amount: Type.Number() }),
-     *     output: Type.Object({ current: Type.Number() }),
-     *     async handler(ctx, input) {
-     *       ctx.state.count += input.amount;
-     *       return Ok({ current: ctx.state.count });
-     *     }
-     *   }),
-     * })
-     *
-     * const MyService = MyServiceScaffold.finalize({
-     *   ...incrementProcedures,
-     *   // you can also directly define procedures here
-     * });
-     * ```
-     * This might be really handy if you have a very large service and you're
-     * wanting to split it over multiple files. You can define the scaffold
-     * in one file, and then import that scaffold in other files where you
-     * define procedures - and then finally import the scaffolds and your
-     * procedure objects in a final file where you finalize the scaffold into
-     * a service schema.
-     *
-     * The other way is to use it like in a builder pattern:
-     * ```ts
-     * const MyService = ServiceSchema
-     *   .scaffold({ initializeState: () => ({ count: 0 }) })
-     *   .finalize({
-     *     increment: Procedure.rpc({
-     *       input: Type.Object({ amount: Type.Number() }),
-     *       output: Type.Object({ current: Type.Number() }),
-     *       async handler(ctx, input) {
-     *         ctx.state.count += input.amount;
-     *         return Ok({ current: ctx.state.count });
-     *       }
-     *     }),
-     *   })
-     * ```
-     * Depending on your preferences, this may be a more appealing way to define
-     * a schema versus using the {@link ServiceSchema.define} method.
-     */
-    static scaffold<State extends object>(config: ServiceConfiguration<State>): ServiceScaffold<State>;
-    /**
-     * Creates a new {@link ServiceSchema} with the given configuration and procedures.
-     *
-     * All procedures must be created with the {@link Procedure} constructors.
-     *
-     * NOTE: There is an overload that lets you just provide the procedures alone if your
-     * service has no state.
-     *
-     * @param config - The configuration for this service.
-     * @param procedures - The procedures for this service.
-     *
-     * @example
-     * ```
-     * const service = ServiceSchema.define(
-     *   { initializeState: () => ({ count: 0 }) },
-     *   {
-     *     increment: Procedure.rpc({
-     *       input: Type.Object({ amount: Type.Number() }),
-     *       output: Type.Object({ current: Type.Number() }),
-     *       async handler(ctx, input) {
-     *         ctx.state.count += input.amount;
-     *         return Ok({ current: ctx.state.count });
-     *       }
-     *     }),
-     *   },
-     * );
-     * ```
-     */
-    static define<State extends object, Procedures extends BrandedProcedureMap<State>>(config: ServiceConfiguration<State>, procedures: Procedures): ServiceSchema<State, {
-        [K in keyof Procedures]: Unbranded<Procedures[K]>;
-    }>;
-    /**
-     * Creates a new {@link ServiceSchema} with the given procedures.
-     *
-     * All procedures must be created with the {@link Procedure} constructors.
-     *
-     * NOTE: There is an overload that lets you provide configuration as well,
-     * if your service has extra configuration like a state.
-     *
-     * @param procedures - The procedures for this service.
-     *
-     * @example
-     * ```
-     * const service = ServiceSchema.define({
-     *   add: Procedure.rpc({
-     *     input: Type.Object({ a: Type.Number(), b: Type.Number() }),
-     *     output: Type.Object({ result: Type.Number() }),
-     *     async handler(ctx, input) {
-     *       return Ok({ result: input.a + input.b });
-     *     }
-     *   }),
-     * });
-     */
-    static define<Procedures extends BrandedProcedureMap<Record<string, never>>>(procedures: Procedures): ServiceSchema<Record<string, never>, {
-        [K in keyof Procedures]: Unbranded<Procedures[K]>;
-    }>;
-    /**
-     * Serializes this schema's procedures into a plain object that is JSON compatible.
-     */
-    serialize(): SerializedServiceSchema;
-    /**
-     * Instantiates this schema into a {@link Service} object.
-     *
-     * You probably don't need this, usually the River server will handle this
-     * for you.
-     */
-    instantiate(): Service<State, Procedures>;
-}
-/**
- * A scaffold for defining a service's procedures.
- *
- * @see {@link ServiceSchema.scaffold}
- */
-declare class ServiceScaffold<State extends object> {
-    /**
-     * The configuration for this service.
-     */
-    protected readonly config: ServiceConfiguration<State>;
-    /**
-     * @param config - The configuration for this service.
-     */
-    constructor(config: ServiceConfiguration<State>);
-    /**
-     * Define procedures for this service. Use the {@link Procedure} constructors
-     * to create them. This returns the procedures object, which can then be
-     * passed to {@link ServiceSchema.finalize} to create a {@link ServiceSchema}.
-     *
-     * @example
-     * ```
-     * const myProcedures = MyServiceScaffold.procedures({
-     *   myRPC: Procedure.rpc({
-     *     // ...
-     *   }),
-     * });
-     *
-     * const MyService = MyServiceScaffold.finalize({
-     *   ...myProcedures,
-     * });
-     * ```
-     *
-     * @param procedures - The procedures for this service.
-     */
-    procedures<T extends BrandedProcedureMap<State>>(procedures: T): T;
-    /**
-     * Finalizes the scaffold into a {@link ServiceSchema}. This is where you
-     * provide the service's procedures and get a {@link ServiceSchema} in return.
-     *
-     * You can directly define procedures here, or you can define them separately
-     * with the {@link ServiceScaffold.procedures} method, and then pass them here.
-     *
-     * @example
-     * ```
-     * const MyService = MyServiceScaffold.finalize({
-     *  myRPC: Procedure.rpc({
-     *   // ...
-     *  }),
-     *  // e.g. from the procedures method
-     *  ...myOtherProcedures,
-     * });
-     * ```
-     */
-    finalize<T extends BrandedProcedureMap<State>>(procedures: T): ServiceSchema<State, {
-        [K in keyof T]: Unbranded<T[K]>;
-    }>;
-}
-
-type AsyncIter<T> = AsyncGenerator<T, T>;
-/**
- * A helper type to transform an actual service type into a type
- * we can case to in the proxy.
- * @template Router - The type of the Router.
- */
-type ServiceClient<Router extends AnyService> = {
-    [ProcName in keyof Router['procedures']]: ProcType<Router, ProcName> extends 'rpc' ? {
-        rpc: (input: Static<ProcInput<Router, ProcName>>) => Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>;
-    } : ProcType<Router, ProcName> extends 'upload' ? ProcHasInit<Router, ProcName> extends true ? {
-        upload: (init: Static<ProcInit<Router, ProcName>>) => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>
-        ]>;
-    } : {
-        upload: () => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>
-        ]>;
-    } : ProcType<Router, ProcName> extends 'stream' ? ProcHasInit<Router, ProcName> extends true ? {
-        stream: (init: Static<ProcInit<Router, ProcName>>) => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
-            () => void
-        ]>;
-    } : {
-        stream: () => Promise<[
-            Pushable<Static<ProcInput<Router, ProcName>>>,
-            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
-            () => void
-        ]>;
-    } : ProcType<Router, ProcName> extends 'subscription' ? {
-        subscribe: (input: Static<ProcInput<Router, ProcName>>) => Promise<[
-            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
-            () => void
-        ]>;
-    } : never;
-};
-/**
- * Defines a type that represents a client for a server with a set of services.
- * @template Srv - The type of the server.
- */
-type Client<Services extends AnyServiceSchemaMap, IS extends InstantiatedServiceSchemaMap<Services> = InstantiatedServiceSchemaMap<Services>> = {
-    [SvcName in keyof IS]: ServiceClient<IS[SvcName]>;
-};
-interface ClientOptions {
-    connectOnInvoke: boolean;
-    eagerlyConnect: boolean;
-}
-/**
- * Creates a client for a given server using the provided transport.
- * Note that the client only needs the type of the server, not the actual
- * server definition itself.
- *
- * This relies on a proxy to dynamically create the client, so the client
- * will be typed as if it were the actual server with the appropriate services
- * and procedures.
- *
- * @template Srv - The type of the server.
- * @param {Transport} transport - The transport to use for communication.
- * @returns The client for the server.
- */
-declare const createClient: <ServiceSchemaMap extends AnyServiceSchemaMap>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => Client<ServiceSchemaMap, InstantiatedServiceSchemaMap<ServiceSchemaMap>>;
-
 /**
  * Represents a server with a set of services. Use {@link createServer} to create it.
  * @template Services - The type of services provided by the server.
@@ -412,6 +36,6 @@ interface ProcStream {
  */
 declare function createServer<Services extends AnyServiceSchemaMap>(transport: ServerTransport<Connection>, services: Services, extendedContext?: Omit<ServiceContext, 'state'>): Server<Services>;
 
-var version = "0.18.5";
+var version = "0.19.2";
 
-export { Client, PayloadType, ProcErrors, ProcHandler, ProcInit, ProcInput, ProcOutput, ProcType, ProcedureMap, version as RIVER_VERSION, Result, RiverError, RiverUncaughtSchema, SerializedServerSchema, Server, Service, ServiceConfiguration, ServiceContext, ServiceSchema, createClient, createServer, serializeSchema };
+export { PayloadType, version as RIVER_VERSION, Result, RiverError, Server, ServiceContext, createServer };

package/dist/router/index.js

@@ -9,9 +9,9 @@ import {
   createServer,
   serializeSchema,
   version
-} from "../chunk-6Q3MSICL.js";
-import "../chunk-VH3NGOXQ.js";
-import "../chunk-WER2DWCP.js";
+} from "../chunk-SR4DBLJ6.js";
+import "../chunk-D5PVGZPQ.js";
+import "../chunk-NBE3D667.js";
 export {
   Err,
   Ok,