@replit/river 0.208.3 → 0.209.0

package/dist/router/index.cjs

@@ -27,13 +27,13 @@ __export(router_exports, {
   Procedure: () => Procedure,
   RIVER_VERSION: () => version,
   ReaderErrorSchema: () => ReaderErrorSchema,
-  ServiceSchema: () => ServiceSchema,
   UNCAUGHT_ERROR_CODE: () => UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE: () => UNEXPECTED_DISCONNECT_CODE,
   createClient: () => createClient,
   createClientHandshakeOptions: () => createClientHandshakeOptions,
   createServer: () => createServer,
   createServerHandshakeOptions: () => createServerHandshakeOptions,
+  createServiceSchema: () => createServiceSchema,
   flattenErrorType: () => flattenErrorType,
   serializeSchema: () => serializeSchema,
   serializeSchemaV1Compat: () => serializeSchemaV1Compat
@@ -146,182 +146,184 @@ function serializeSchema(services, handshakeSchema) {
   }
   return schema;
 }
-var ServiceSchema = class _ServiceSchema {
-  /**
-   * Factory function for creating a fresh state.
-   */
-  initializeState;
-  /**
-   * The procedures for this service.
-   */
-  procedures;
-  /**
-   * @param config - The configuration for this service.
-   * @param procedures - The procedures for this service.
-   */
-  constructor(config, procedures) {
-    this.initializeState = config.initializeState;
-    this.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({
-   *     requestInit: Type.Object({ amount: Type.Number() }),
-   *     responseData: Type.Object({ current: Type.Number() }),
-   *     async handler(ctx, init) {
-   *       ctx.state.count += init.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({
-   *       requestInit: Type.Object({ amount: Type.Number() }),
-   *       responseData: Type.Object({ current: Type.Number() }),
-   *       async handler(ctx, init) {
-   *         ctx.state.count += init.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(config) {
-    return new ServiceScaffold(config);
-  }
-  // actual implementation
-  static define(configOrProcedures, maybeProcedures) {
-    let config;
-    let procedures;
-    if ("initializeState" in configOrProcedures && typeof configOrProcedures.initializeState === "function") {
-      if (!maybeProcedures) {
-        throw new Error("Expected procedures to be defined");
+function createServiceSchema() {
+  return class ServiceSchema {
+    /**
+     * Factory function for creating a fresh state.
+     */
+    initializeState;
+    /**
+     * The procedures for this service.
+     */
+    procedures;
+    /**
+     * @param config - The configuration for this service.
+     * @param procedures - The procedures for this service.
+     */
+    constructor(config, procedures) {
+      this.initializeState = config.initializeState;
+      this.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({
+     *     requestInit: Type.Object({ amount: Type.Number() }),
+     *     responseData: Type.Object({ current: Type.Number() }),
+     *     async handler(ctx, init) {
+     *       ctx.state.count += init.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({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.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(config) {
+      return new ServiceScaffold(config);
+    }
+    // actual implementation
+    static define(configOrProcedures, maybeProcedures) {
+      let config;
+      let procedures;
+      if ("initializeState" in configOrProcedures && typeof configOrProcedures.initializeState === "function") {
+        if (!maybeProcedures) {
+          throw new Error("Expected procedures to be defined");
+        }
+        config = configOrProcedures;
+        procedures = maybeProcedures;
+      } else {
+        config = { initializeState: () => ({}) };
+        procedures = configOrProcedures;
       }
-      config = configOrProcedures;
-      procedures = maybeProcedures;
-    } else {
-      config = { initializeState: () => ({}) };
-      procedures = configOrProcedures;
+      return new ServiceSchema(config, procedures);
     }
-    return new _ServiceSchema(config, procedures);
-  }
-  /**
-   * Serializes this schema's procedures into a plain object that is JSON compatible.
-   */
-  serialize() {
-    return {
-      procedures: Object.fromEntries(
-        Object.entries(this.procedures).map(([procName, procDef]) => [
-          procName,
-          {
-            init: Strict(procDef.requestInit),
-            output: Strict(procDef.responseData),
-            errors: getSerializedProcErrors(procDef),
-            // Only add `description` field if the type declares it.
-            ..."description" in procDef ? { description: procDef.description } : {},
-            type: procDef.type,
-            // Only add the `input` field if the type declares it.
-            ..."requestData" in procDef ? {
-              input: Strict(procDef.requestData)
-            } : {}
-          }
-        ])
-      )
-    };
-  }
-  // TODO remove once clients migrate to v2
-  /**
-   * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
-   * protocol v1. This is useful to be able to continue to generate schemas for older
-   * clients as they are still supported.
-   */
-  serializeV1Compat() {
-    return {
-      procedures: Object.fromEntries(
-        Object.entries(this.procedures).map(
-          ([procName, procDef]) => {
-            if (procDef.type === "rpc" || procDef.type === "subscription") {
+    /**
+     * Serializes this schema's procedures into a plain object that is JSON compatible.
+     */
+    serialize() {
+      return {
+        procedures: Object.fromEntries(
+          Object.entries(this.procedures).map(([procName, procDef]) => [
+            procName,
+            {
+              init: Strict(procDef.requestInit),
+              output: Strict(procDef.responseData),
+              errors: getSerializedProcErrors(procDef),
+              // Only add `description` field if the type declares it.
+              ..."description" in procDef ? { description: procDef.description } : {},
+              type: procDef.type,
+              // Only add the `input` field if the type declares it.
+              ..."requestData" in procDef ? {
+                input: Strict(procDef.requestData)
+              } : {}
+            }
+          ])
+        )
+      };
+    }
+    // TODO remove once clients migrate to v2
+    /**
+     * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+     * protocol v1. This is useful to be able to continue to generate schemas for older
+     * clients as they are still supported.
+     */
+    serializeV1Compat() {
+      return {
+        procedures: Object.fromEntries(
+          Object.entries(this.procedures).map(
+            ([procName, procDef]) => {
+              if (procDef.type === "rpc" || procDef.type === "subscription") {
+                return [
+                  procName,
+                  {
+                    // BACKWARDS COMPAT: map init to input for protocolv1
+                    // this is the only change needed to make it compatible.
+                    input: Strict(procDef.requestInit),
+                    output: Strict(procDef.responseData),
+                    errors: getSerializedProcErrors(procDef),
+                    // Only add `description` field if the type declares it.
+                    ..."description" in procDef ? { description: procDef.description } : {},
+                    type: procDef.type
+                  }
+                ];
+              }
               return [
                 procName,
                 {
-                  // BACKWARDS COMPAT: map init to input for protocolv1
-                  // this is the only change needed to make it compatible.
-                  input: Strict(procDef.requestInit),
+                  init: Strict(procDef.requestInit),
                   output: Strict(procDef.responseData),
                   errors: getSerializedProcErrors(procDef),
                   // Only add `description` field if the type declares it.
                   ..."description" in procDef ? { description: procDef.description } : {},
-                  type: procDef.type
+                  type: procDef.type,
+                  input: Strict(procDef.requestData)
                 }
               ];
             }
-            return [
-              procName,
-              {
-                init: Strict(procDef.requestInit),
-                output: Strict(procDef.responseData),
-                errors: getSerializedProcErrors(procDef),
-                // Only add `description` field if the type declares it.
-                ..."description" in procDef ? { description: procDef.description } : {},
-                type: procDef.type,
-                input: Strict(procDef.requestData)
-              }
-            ];
-          }
+          )
         )
-      )
-    };
-  }
-  /**
-   * Instantiates this schema into a {@link Service} object.
-   *
-   * You probably don't need this, usually the River server will handle this
-   * for you.
-   */
-  instantiate(extendedContext) {
-    const state = this.initializeState(extendedContext);
-    const dispose = async () => {
-      await state[Symbol.asyncDispose]?.();
-      state[Symbol.dispose]?.();
-    };
-    return Object.freeze({
-      state,
-      procedures: this.procedures,
-      [Symbol.asyncDispose]: dispose
-    });
-  }
-};
+      };
+    }
+    /**
+     * Instantiates this schema into a {@link Service} object.
+     *
+     * You probably don't need this, usually the River server will handle this
+     * for you.
+     */
+    instantiate(extendedContext) {
+      const state = this.initializeState(extendedContext);
+      const dispose = async () => {
+        await state[Symbol.asyncDispose]?.();
+        state[Symbol.dispose]?.();
+      };
+      return Object.freeze({
+        state,
+        procedures: this.procedures,
+        [Symbol.asyncDispose]: dispose
+      });
+    }
+  };
+}
 function getSerializedProcErrors(procDef) {
   if (!("responseError" in procDef) || procDef.responseError[import_typebox2.Kind] === "Never") {
     return Strict(ReaderErrorSchema);
@@ -384,7 +386,10 @@ var ServiceScaffold = class {
    * ```
    */
   finalize(procedures) {
-    return ServiceSchema.define(this.config, procedures);
+    return createServiceSchema().define(
+      this.config,
+      procedures
+    );
   }
 };
 
@@ -964,6 +969,9 @@ function createClient(transport, serverId, providedClientOptions = {}) {
   }, []);
 }
 function handleProc(procType, transport, serverId, init, serviceName, procedureName, abortSignal) {
+  if (transport.getStatus() === "closed") {
+    return getPreClosedReturnForProc(procType);
+  }
   const session = transport.sessions.get(serverId) ?? transport.createUnconnectedSession(serverId);
   const sessionScopedSend = transport.getSessionBoundSendFn(
     serverId,
@@ -1140,13 +1148,33 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
   if (procClosesWithInit) {
     reqWritable.close();
   }
+  return getReturnForProc(procType, resReadable, reqWritable, transport.log);
+}
+function getPreClosedReturnForProc(procType) {
+  const readable = new ReadableImpl();
+  const err = Err({
+    code: UNEXPECTED_DISCONNECT_CODE,
+    message: `transport is closed`
+  });
+  readable._pushValue(err);
+  readable._triggerClose();
+  const writable = new WritableImpl({
+    writeCb: () => {
+    },
+    closeCb: () => {
+    }
+  });
+  writable.close();
+  return getReturnForProc(procType, readable, writable);
+}
+function getReturnForProc(procType, resReadable, reqWritable, log) {
   if (procType === "subscription") {
     return {
       resReadable
     };
   }
   if (procType === "rpc") {
-    return getSingleMessage(resReadable, transport.log);
+    return getSingleMessage(resReadable, log);
   }
   if (procType === "upload") {
     let didFinalize = false;
@@ -1160,7 +1188,7 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
         if (!reqWritable.isClosed()) {
           reqWritable.close();
         }
-        return getSingleMessage(resReadable, transport.log);
+        return getSingleMessage(resReadable, log);
       }
     };
   }
@@ -1211,8 +1239,9 @@ var RiverServer = class {
     this.middlewares = middlewares;
     this.services = instances;
     this.contextMap = /* @__PURE__ */ new Map();
+    extendedContext = extendedContext ?? {};
     for (const [name, service] of Object.entries(services)) {
-      const instance = service.instantiate(extendedContext ?? {});
+      const instance = service.instantiate(extendedContext);
       instances[name] = instance;
       this.contextMap.set(instance, {
         ...extendedContext,
@@ -1895,7 +1924,7 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.208.3";
+var version = "0.209.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CANCEL_CODE,
@@ -1905,13 +1934,13 @@ var version = "0.208.3";
   Procedure,
   RIVER_VERSION,
   ReaderErrorSchema,
-  ServiceSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
   createClient,
   createClientHandshakeOptions,
   createServer,
   createServerHandshakeOptions,
+  createServiceSchema,
   flattenErrorType,
   serializeSchema,
   serializeSchemaV1Compat