@replit/river 0.208.3 → 0.209.0

package/README.md

@@ -272,4 +272,39 @@ You can find more service examples in the [E2E test fixtures](https://github.com
 - `npm run check` -- lint
 - `npm run format` -- format
 - `npm run test` -- run tests
-- `npm run publish` -- cut a new release (should bump version in package.json first)
+- `npm run release` -- cut a new release (should bump version in package.json first)
+
+## Releasing
+
+River uses an automated release process with [Release Drafter](https://github.com/release-drafter/release-drafter) for version management and NPM publishing.
+
+### Automated Release Process (Recommended)
+
+1. **Merge PRs to main** - Release Drafter automatically:
+
+   - Updates the draft release notes with PR titles
+   - You can view the draft at [GitHub Releases](../../releases)
+
+2. **When ready to release, create a version bump PR**:
+
+   - Create a PR that bumps the version in `package.json` and `package-lock.json`. You can run `pnpm version --no-git-tag-version <version>` to bump the version.
+   - Use semantic versioning:
+     - `patch` - Bug fixes, small improvements (e.g., 0.208.4 → 0.208.5)
+     - `minor` - New features, backwards compatible (e.g., 0.208.4 → 0.209.0)
+     - `major` - Breaking changes (e.g., 0.208.4 → 1.0.0)
+   - Merge the PR to main
+
+3. **Publish the GitHub release**:
+
+   - Go to [GitHub Releases](../../releases)
+   - Find the draft release and click "Edit"
+   - Update the tag to match your new version (e.g., `v0.209.0`)
+   - Click "Publish release"
+
+4. **Automation takes over**:
+
+   - Publishing the release automatically triggers the "Build and Publish" workflow
+   - The `river` package is published to NPM
+
+5. **Manual npm release**:
+   - If the auto-publish workflow failed, you can run `npm run release` locally

package/dist/{adapter-ChksXKVN.d.ts → adapter-Cp7_gIVA.d.ts}

@@ -1,4 +1,4 @@
-import { O as OpaqueTransportMessage } from './message-Di94OL80.js';
+import { b as OpaqueTransportMessage } from './message-Dlsh5WDF.js';
 
 /**
  * Codec interface for encoding and decoding objects to and from Uint8 buffers.

package/dist/{adapter-Cuc4JtfV.d.cts → adapter-DjiEwOYi.d.cts}

@@ -1,4 +1,4 @@
-import { O as OpaqueTransportMessage } from './message-Di94OL80.cjs';
+import { b as OpaqueTransportMessage } from './message-Dlsh5WDF.cjs';
 
 /**
  * Codec interface for encoding and decoding objects to and from Uint8 buffers.

package/dist/{chunk-M2B4PVR5.js → chunk-LPWARXI3.js}

@@ -1,6 +1,6 @@
 import {
   Connection
-} from "./chunk-3WYK5ZRT.js";
+} from "./chunk-TVN2TB6X.js";
 
 // transport/impls/ws/connection.ts
 var WS_HEALTHY_CLOSE_CODE = 1e3;
@@ -52,4 +52,4 @@ var WebSocketConnection = class extends Connection {
 export {
   WebSocketConnection
 };
-//# sourceMappingURL=chunk-M2B4PVR5.js.map
+//# sourceMappingURL=chunk-LPWARXI3.js.map

package/dist/{chunk-JC4XN6NC.js → chunk-RATCBAZE.js}

@@ -107,182 +107,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[Kind2] === "Never") {
     return Strict(ReaderErrorSchema);
@@ -345,7 +347,10 @@ var ServiceScaffold = class {
    * ```
    */
   finalize(procedures) {
-    return ServiceSchema.define(this.config, procedures);
+    return createServiceSchema().define(
+      this.config,
+      procedures
+    );
   }
 };
 
@@ -1019,6 +1024,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,
@@ -1195,13 +1203,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;
@@ -1215,7 +1243,7 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
         if (!reqWritable.isClosed()) {
           reqWritable.close();
         }
-        return getSingleMessage(resReadable, transport.log);
+        return getSingleMessage(resReadable, log);
       }
     };
   }
@@ -1266,8 +1294,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,
@@ -1950,7 +1979,7 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.208.3";
+var version = "0.209.0";
 
 export {
   generateId,
@@ -1974,7 +2003,7 @@ export {
   flattenErrorType,
   serializeSchemaV1Compat,
   serializeSchema,
-  ServiceSchema,
+  createServiceSchema,
   Procedure,
   Ok,
   Err,
@@ -1989,4 +2018,4 @@ export {
   createConnectionTelemetryInfo,
   getTracer
 };
-//# sourceMappingURL=chunk-JC4XN6NC.js.map
+//# sourceMappingURL=chunk-RATCBAZE.js.map