@replit/river 0.23.16 → 0.200.0-rc.0

package/dist/util/testHelpers.cjs

@@ -38,6 +38,7 @@ __export(testHelpers_exports, {
   createLocalWebSocketClient: () => createLocalWebSocketClient,
   createWebSocketServer: () => createWebSocketServer,
   dummySession: () => dummySession,
+  getIteratorFromStream: () => getIteratorFromStream,
   getUnixSocketPath: () => getUnixSocketPath,
   iterNext: () => iterNext,
   onUdsServeReady: () => onUdsServeReady,
@@ -49,299 +50,55 @@ __export(testHelpers_exports, {
 module.exports = __toCommonJS(testHelpers_exports);
 var import_ws = __toESM(require("ws"), 1);
 
-// node_modules/p-defer/index.js
-function pDefer() {
-  const deferred = {};
-  deferred.promise = new Promise((resolve, reject) => {
-    deferred.resolve = resolve;
-    deferred.reject = reject;
-  });
-  return deferred;
-}
-
-// node_modules/it-pushable/dist/src/fifo.js
-var FixedFIFO = class {
-  buffer;
-  mask;
-  top;
-  btm;
-  next;
-  constructor(hwm) {
-    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
-      throw new Error("Max size for a FixedFIFO should be a power of two");
-    }
-    this.buffer = new Array(hwm);
-    this.mask = hwm - 1;
-    this.top = 0;
-    this.btm = 0;
-    this.next = null;
-  }
-  push(data) {
-    if (this.buffer[this.top] !== void 0) {
-      return false;
-    }
-    this.buffer[this.top] = data;
-    this.top = this.top + 1 & this.mask;
-    return true;
-  }
-  shift() {
-    const last = this.buffer[this.btm];
-    if (last === void 0) {
-      return void 0;
-    }
-    this.buffer[this.btm] = void 0;
-    this.btm = this.btm + 1 & this.mask;
-    return last;
-  }
-  isEmpty() {
-    return this.buffer[this.btm] === void 0;
-  }
-};
-var FIFO = class {
-  size;
-  hwm;
-  head;
-  tail;
-  constructor(options = {}) {
-    this.hwm = options.splitLimit ?? 16;
-    this.head = new FixedFIFO(this.hwm);
-    this.tail = this.head;
-    this.size = 0;
-  }
-  calculateSize(obj) {
-    if (obj?.byteLength != null) {
-      return obj.byteLength;
-    }
-    return 1;
-  }
-  push(val) {
-    if (val?.value != null) {
-      this.size += this.calculateSize(val.value);
-    }
-    if (!this.head.push(val)) {
-      const prev = this.head;
-      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
-      this.head.push(val);
-    }
-  }
-  shift() {
-    let val = this.tail.shift();
-    if (val === void 0 && this.tail.next != null) {
-      const next = this.tail.next;
-      this.tail.next = null;
-      this.tail = next;
-      val = this.tail.shift();
-    }
-    if (val?.value != null) {
-      this.size -= this.calculateSize(val.value);
-    }
-    return val;
-  }
-  isEmpty() {
-    return this.head.isEmpty();
-  }
-};
-
-// node_modules/it-pushable/dist/src/index.js
-var AbortError = class extends Error {
-  type;
-  code;
-  constructor(message, code) {
-    super(message ?? "The operation was aborted");
-    this.type = "aborted";
-    this.code = code ?? "ABORT_ERR";
-  }
-};
-function pushable(options = {}) {
-  const getNext = (buffer) => {
-    const next = buffer.shift();
-    if (next == null) {
-      return { done: true };
-    }
-    if (next.error != null) {
-      throw next.error;
-    }
-    return {
-      done: next.done === true,
-      // @ts-expect-error if done is false, value will be present
-      value: next.value
-    };
-  };
-  return _pushable(getNext, options);
-}
-function _pushable(getNext, options) {
-  options = options ?? {};
-  let onEnd = options.onEnd;
-  let buffer = new FIFO();
-  let pushable2;
-  let onNext;
-  let ended;
-  let drain = pDefer();
-  const waitNext = async () => {
-    try {
-      if (!buffer.isEmpty()) {
-        return getNext(buffer);
-      }
-      if (ended) {
-        return { done: true };
-      }
-      return await new Promise((resolve, reject) => {
-        onNext = (next) => {
-          onNext = null;
-          buffer.push(next);
-          try {
-            resolve(getNext(buffer));
-          } catch (err) {
-            reject(err);
-          }
-          return pushable2;
-        };
-      });
-    } finally {
-      if (buffer.isEmpty()) {
-        queueMicrotask(() => {
-          drain.resolve();
-          drain = pDefer();
-        });
-      }
-    }
-  };
-  const bufferNext = (next) => {
-    if (onNext != null) {
-      return onNext(next);
-    }
-    buffer.push(next);
-    return pushable2;
-  };
-  const bufferError = (err) => {
-    buffer = new FIFO();
-    if (onNext != null) {
-      return onNext({ error: err });
-    }
-    buffer.push({ error: err });
-    return pushable2;
-  };
-  const push = (value) => {
-    if (ended) {
-      return pushable2;
-    }
-    if (options?.objectMode !== true && value?.byteLength == null) {
-      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
-    }
-    return bufferNext({ done: false, value });
-  };
-  const end = (err) => {
-    if (ended)
-      return pushable2;
-    ended = true;
-    return err != null ? bufferError(err) : bufferNext({ done: true });
-  };
-  const _return = () => {
-    buffer = new FIFO();
-    end();
-    return { done: true };
-  };
-  const _throw = (err) => {
-    end(err);
-    return { done: true };
-  };
-  pushable2 = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next: waitNext,
-    return: _return,
-    throw: _throw,
-    push,
-    end,
-    get readableLength() {
-      return buffer.size;
-    },
-    onEmpty: async (options2) => {
-      const signal = options2?.signal;
-      signal?.throwIfAborted();
-      if (buffer.isEmpty()) {
-        return;
-      }
-      let cancel;
-      let listener;
-      if (signal != null) {
-        cancel = new Promise((resolve, reject) => {
-          listener = () => {
-            reject(new AbortError());
-          };
-          signal.addEventListener("abort", listener);
-        });
-      }
-      try {
-        await Promise.race([
-          drain.promise,
-          cancel
-        ]);
-      } finally {
-        if (listener != null && signal != null) {
-          signal?.removeEventListener("abort", listener);
-        }
-      }
-    }
-  };
-  if (onEnd == null) {
-    return pushable2;
-  }
-  const _pushable2 = pushable2;
-  pushable2 = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next() {
-      return _pushable2.next();
-    },
-    throw(err) {
-      _pushable2.throw(err);
-      if (onEnd != null) {
-        onEnd(err);
-        onEnd = void 0;
-      }
-      return { done: true };
-    },
-    return() {
-      _pushable2.return();
-      if (onEnd != null) {
-        onEnd();
-        onEnd = void 0;
-      }
-      return { done: true };
-    },
-    push,
-    end(err) {
-      _pushable2.end(err);
-      if (onEnd != null) {
-        onEnd(err);
-        onEnd = void 0;
-      }
-      return pushable2;
-    },
-    get readableLength() {
-      return _pushable2.readableLength;
-    },
-    onEmpty: (opts) => {
-      return _pushable2.onEmpty(opts);
-    }
-  };
-  return pushable2;
-}
-
-// router/result.ts
+// router/procedures.ts
 var import_typebox = require("@sinclair/typebox");
-var UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
-var UNEXPECTED_DISCONNECT = "UNEXPECTED_DISCONNECT";
-var RiverUncaughtSchema = import_typebox.Type.Object({
+var INTERNAL_RIVER_ERROR_CODE = "INTERNAL_RIVER_ERROR";
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var ABORT_CODE = "ABORT";
+var OutputReaderErrorSchema = import_typebox.Type.Object({
   code: import_typebox.Type.Union([
-    import_typebox.Type.Literal(UNCAUGHT_ERROR),
-    import_typebox.Type.Literal(UNEXPECTED_DISCONNECT)
+    import_typebox.Type.Literal(INTERNAL_RIVER_ERROR_CODE),
+    import_typebox.Type.Literal(UNCAUGHT_ERROR_CODE),
+    import_typebox.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    import_typebox.Type.Literal(INVALID_REQUEST_CODE),
+    import_typebox.Type.Literal(ABORT_CODE)
   ]),
   message: import_typebox.Type.String()
 });
+var InputReaderErrorSchema = import_typebox.Type.Object({
+  code: import_typebox.Type.Union([
+    import_typebox.Type.Literal(UNCAUGHT_ERROR_CODE),
+    import_typebox.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    import_typebox.Type.Literal(INVALID_REQUEST_CODE),
+    import_typebox.Type.Literal(ABORT_CODE)
+  ]),
+  message: import_typebox.Type.String()
+});
+
+// router/result.ts
+var import_typebox2 = require("@sinclair/typebox");
+var AnyResultSchema = import_typebox2.Type.Union([
+  import_typebox2.Type.Object({
+    ok: import_typebox2.Type.Literal(false),
+    payload: import_typebox2.Type.Object({
+      code: import_typebox2.Type.String(),
+      message: import_typebox2.Type.String(),
+      extras: import_typebox2.Type.Optional(import_typebox2.Type.Unknown())
+    })
+  }),
+  import_typebox2.Type.Object({
+    ok: import_typebox2.Type.Literal(true),
+    payload: import_typebox2.Type.Unknown()
+  })
+]);
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
 function Err(error) {
   return {
     ok: false,
@@ -353,7 +110,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.16";
+var version = "0.200.0-rc.0";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(session, propagationCtx) {
@@ -375,6 +132,261 @@ function createSessionTelemetryInfo(session, propagationCtx) {
 }
 var tracer = import_api.trace.getTracer("river", version);
 
+// router/streams.ts
+var StreamDrainedError = {
+  code: "STREAM_DRAINED",
+  message: "Stream was drained"
+};
+var ReadStreamImpl = class {
+  /**
+   * Whether the stream is closed.
+   */
+  closed = false;
+  /**
+   * A list of listeners that will be called when the stream is closed.
+   */
+  onCloseListeners;
+  /**
+   * Whether the user has requested to close the stream.
+   */
+  closeRequested = false;
+  /**
+   * Used to signal to the outside world that the user has requested to close the stream.
+   */
+  closeRequestCallback;
+  /**
+   * Whether the stream is locked.
+   */
+  locked = false;
+  /**
+   * Whether drain was called.
+   */
+  drained = false;
+  /**
+   * This flag allows us to avoid cases where drain was called,
+   * but the stream is fully consumed and closed. We don't need
+   * to signal that drain was closed.
+   */
+  didDrainDisposeValues = false;
+  /**
+   * A list of values that have been pushed to the stream but not yet emitted to the user.
+   */
+  queue = [];
+  /**
+   * Used by methods in the class to signal to the iterator that it
+   * should check for the next value.
+   */
+  nextPromise = null;
+  /**
+   * Resolves nextPromise
+   */
+  resolveNextPromise = null;
+  constructor(closeRequestCallback) {
+    this.closeRequestCallback = closeRequestCallback;
+    this.onCloseListeners = /* @__PURE__ */ new Set();
+  }
+  [Symbol.asyncIterator]() {
+    if (this.isLocked()) {
+      throw new TypeError("ReadStream is already locked");
+    }
+    let didSignalDrain = false;
+    this.locked = true;
+    return {
+      next: async () => {
+        if (this.drained && didSignalDrain) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        while (this.queue.length === 0) {
+          if (this.isClosed() && !this.didDrainDisposeValues) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          if (this.drained) {
+            didSignalDrain = true;
+            return {
+              done: false,
+              value: Err(StreamDrainedError)
+            };
+          }
+          if (!this.nextPromise) {
+            this.nextPromise = new Promise((resolve) => {
+              this.resolveNextPromise = resolve;
+            });
+          }
+          await this.nextPromise;
+          this.nextPromise = null;
+          this.resolveNextPromise = null;
+        }
+        const value = this.queue.shift();
+        return { done: false, value };
+      },
+      return: async () => {
+        this.drain();
+        return { done: true, value: void 0 };
+      }
+    };
+  }
+  async asArray() {
+    const array = [];
+    for await (const value of this) {
+      array.push(value);
+    }
+    return array;
+  }
+  drain() {
+    if (this.drained) {
+      return;
+    }
+    this.locked = true;
+    this.drained = true;
+    this.didDrainDisposeValues = this.queue.length > 0;
+    this.queue.length = 0;
+    this.resolveNextPromise?.();
+  }
+  isClosed() {
+    return this.closed;
+  }
+  isLocked() {
+    return this.locked;
+  }
+  onClose(cb) {
+    if (this.isClosed()) {
+      throw new Error("Stream is already closed");
+    }
+    this.onCloseListeners.add(cb);
+    return () => {
+      this.onCloseListeners.delete(cb);
+    };
+  }
+  requestClose() {
+    if (this.isClosed()) {
+      throw new Error("Cannot request close after stream already closed");
+    }
+    if (!this.closeRequested) {
+      this.closeRequested = true;
+      this.closeRequestCallback();
+    }
+    return new Promise((resolve) => {
+      this.onClose(() => {
+        resolve(void 0);
+      });
+    });
+  }
+  isCloseRequested() {
+    return this.closeRequested;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Pushes a value to the stream.
+   */
+  pushValue(value) {
+    if (this.drained) {
+      return;
+    }
+    if (this.closed) {
+      throw new Error("Cannot push to closed stream");
+    }
+    this.queue.push(value);
+    this.resolveNextPromise?.();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Triggers the close of the stream. Make sure to push all remaining
+   * values before calling this method.
+   */
+  triggerClose() {
+    if (this.isClosed()) {
+      throw new Error("Unexpected closing multiple times");
+    }
+    this.closed = true;
+    this.resolveNextPromise?.();
+    this.onCloseListeners.forEach((cb) => cb());
+    this.onCloseListeners.clear();
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   */
+  hasValuesInQueue() {
+    return this.queue.length > 0;
+  }
+};
+var WriteStreamImpl = class {
+  /**
+   * Passed via constructor to pass on write requests
+   */
+  writeCb;
+  /**
+   * Passed via constructor to pass on close requests
+   */
+  closeCb;
+  /**
+   * Whether the stream is closed.
+   */
+  closed = false;
+  /**
+   * Whether the reader has requested to close the stream.
+   */
+  closeRequested = false;
+  /**
+   * A list of listeners that will be called when the stream is closed.
+   */
+  onCloseListeners;
+  constructor(writeCb, closeCb) {
+    this.writeCb = writeCb;
+    this.closeCb = closeCb;
+    this.onCloseListeners = /* @__PURE__ */ new Set();
+  }
+  write(value) {
+    if (this.isClosed()) {
+      throw new Error("Cannot write to closed stream");
+    }
+    this.writeCb(value);
+  }
+  close() {
+    if (this.isClosed()) {
+      return;
+    }
+    this.closed = true;
+    this.closeCb();
+  }
+  isCloseRequested() {
+    return this.closeRequested;
+  }
+  onCloseRequest(cb) {
+    if (this.isClosed()) {
+      throw new Error("Stream is already closed");
+    }
+    this.onCloseListeners.add(cb);
+    return () => this.onCloseListeners.delete(cb);
+  }
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * @internal meant for use within river, not exposed as a public API
+   *
+   * Triggers a close request.
+   */
+  triggerCloseRequest() {
+    if (this.isCloseRequested()) {
+      throw new Error("Cannot trigger close request multiple times");
+    }
+    if (this.isClosed()) {
+      throw new Error("Cannot trigger close request on closed stream");
+    }
+    this.closeRequested = true;
+    this.onCloseListeners.forEach((cb) => cb());
+    this.onCloseListeners.clear();
+  }
+};
+
 // util/stringify.ts
 function coerceErrorString(err) {
   if (err instanceof Error) {
@@ -778,6 +790,9 @@ function onUdsServeReady(server, path) {
     server.listen(path, resolve);
   });
 }
+function getIteratorFromStream(readStream) {
+  return readStream[Symbol.asyncIterator]();
+}
 async function iterNext(iter) {
   return await iter.next().then((res) => res.value);
 }
@@ -813,7 +828,7 @@ async function waitForMessage(t, filter, rejectMismatch) {
 }
 function catchProcError(err) {
   const errorMsg = coerceErrorString(err);
-  return Err({ code: UNCAUGHT_ERROR, message: errorMsg });
+  return Err({ code: UNCAUGHT_ERROR_CODE, message: errorMsg });
 }
 var testingSessionOptions = defaultTransportOptions;
 function dummySession() {
@@ -827,57 +842,85 @@ function dummySession() {
 function dummyCtx(state, session, extendedContext) {
   return {
     ...extendedContext,
-    state,
-    to: session.to,
     from: session.from,
-    streamId: (0, import_nanoid2.nanoid)(),
-    session,
-    metadata: {}
+    state,
+    metadata: {},
+    abortController: new AbortController(),
+    clientAbortSignal: new AbortController().signal,
+    onRequestFinished: () => void 0
   };
 }
 function asClientRpc(state, proc, extendedContext, session = dummySession()) {
   return async (msg) => {
-    return await proc.handler(dummyCtx(state, session, extendedContext), msg).catch(catchProcError);
+    return proc.handler(dummyCtx(state, session, extendedContext), msg).catch(catchProcError);
   };
 }
-function asClientStream(state, proc, init, extendedContext, session = dummySession()) {
-  const input = pushable({ objectMode: true });
-  const output = pushable({
-    objectMode: true
+function createOutputPipe() {
+  const reader = new ReadStreamImpl(() => {
+    void Promise.resolve().then(() => {
+      writer.triggerCloseRequest();
+    });
   });
-  void (async () => {
-    if (init) {
-      const _proc = proc;
-      await _proc.handler(dummyCtx(state, session, extendedContext), init, input, output).catch((err) => output.push(catchProcError(err)));
-    } else {
-      const _proc = proc;
-      await _proc.handler(dummyCtx(state, session, extendedContext), input, output).catch((err) => output.push(catchProcError(err)));
+  const writer = new WriteStreamImpl(
+    (v) => {
+      reader.pushValue(v);
+    },
+    () => {
+      void Promise.resolve().then(() => {
+        reader.triggerClose();
+      });
     }
-  })();
-  return [input, output];
+  );
+  return { reader, writer };
 }
-function asClientSubscription(state, proc, extendedContext, session = dummySession()) {
-  const output = pushable({
-    objectMode: true
+function createInputPipe() {
+  const reader = new ReadStreamImpl(() => {
+    void Promise.resolve().then(() => {
+      writer.triggerCloseRequest();
+    });
   });
+  const writer = new WriteStreamImpl(
+    (v) => {
+      reader.pushValue(Ok(v));
+    },
+    () => {
+      void Promise.resolve().then(() => {
+        reader.triggerClose();
+      });
+    }
+  );
+  return { reader, writer };
+}
+function asClientStream(state, proc, init, extendedContext, session = dummySession()) {
+  const inputPipe = createInputPipe();
+  const outputPipe = createOutputPipe();
+  void proc.handler(
+    dummyCtx(state, session, extendedContext),
+    init ?? {},
+    inputPipe.reader,
+    outputPipe.writer
+  ).catch((err) => outputPipe.writer.write(catchProcError(err)));
+  return [inputPipe.writer, outputPipe.reader];
+}
+function asClientSubscription(state, proc, extendedContext, session = dummySession()) {
+  const outputPipe = createOutputPipe();
   return (msg) => {
-    void (async () => {
-      return await proc.handler(dummyCtx(state, session, extendedContext), msg, output).catch((err) => output.push(catchProcError(err)));
-    })();
-    return output;
+    void proc.handler(
+      dummyCtx(state, session, extendedContext),
+      msg,
+      outputPipe.writer
+    ).catch((err) => outputPipe.writer.write(catchProcError(err)));
+    return outputPipe.reader;
   };
 }
 function asClientUpload(state, proc, init, extendedContext, session = dummySession()) {
-  const input = pushable({ objectMode: true });
-  if (init) {
-    const _proc = proc;
-    const result = _proc.handler(dummyCtx(state, session, extendedContext), init, input).catch(catchProcError);
-    return [input, result];
-  } else {
-    const _proc = proc;
-    const result = _proc.handler(dummyCtx(state, session, extendedContext), input).catch(catchProcError);
-    return [input, result];
-  }
+  const inputPipe = createInputPipe();
+  const result = proc.handler(
+    dummyCtx(state, session, extendedContext),
+    init ?? {},
+    inputPipe.reader
+  ).catch(catchProcError);
+  return [inputPipe.writer, () => result];
 }
 var getUnixSocketPath = () => {
   return process.platform === "win32" ? `\\\\?\\pipe\\${(0, import_nanoid2.nanoid)()}` : `/tmp/${(0, import_nanoid2.nanoid)()}.sock`;
@@ -892,6 +935,7 @@ var getUnixSocketPath = () => {
   createLocalWebSocketClient,
   createWebSocketServer,
   dummySession,
+  getIteratorFromStream,
   getUnixSocketPath,
   iterNext,
   onUdsServeReady,