@replit/river 0.10.0 → 0.10.1

package/dist/chunk-7WJ6YLE5.js

@@ -0,0 +1,683 @@
+import {
+  ControlMessagePayloadSchema,
+  closeStream,
+  isStreamClose,
+  isStreamOpen,
+  msg,
+  reply
+} from "./chunk-ZE4MX7DF.js";
+import {
+  log
+} from "./chunk-SLUSVGQH.js";
+
+// router/builder.ts
+import { Type } from "@sinclair/typebox";
+function serializeService(s) {
+  return {
+    name: s.name,
+    state: s.state,
+    procedures: Object.fromEntries(
+      Object.entries(s.procedures).map(([procName, procDef]) => [
+        procName,
+        {
+          input: Type.Strict(procDef.input),
+          output: Type.Strict(procDef.output),
+          // Only add the `errors` field if it is non-never.
+          ..."errors" in procDef ? {
+            errors: Type.Strict(procDef.errors)
+          } : {},
+          type: procDef.type,
+          // Only add the `init` field if the type declares it.
+          ..."init" in procDef ? {
+            init: Type.Strict(procDef.init)
+          } : {}
+        }
+      ])
+    )
+  };
+}
+var ServiceBuilder = class _ServiceBuilder {
+  schema;
+  constructor(schema) {
+    this.schema = schema;
+  }
+  /**
+   * Finalizes the schema for the service.
+   * @returns {T} The finalized schema for the service.
+   */
+  finalize() {
+    return this.schema;
+  }
+  /**
+   * Sets the initial state for the service.
+   * @template InitState The type of the initial state.
+   * @param {InitState} state The initial state for the service.
+   * @returns {ServiceBuilder<{ name: T['name']; state: InitState; procedures: T['procedures']; }>} A new ServiceBuilder instance with the updated schema.
+   */
+  initialState(state) {
+    return new _ServiceBuilder({
+      ...this.schema,
+      state
+    });
+  }
+  /**
+   * Defines a new procedure for the service.
+   * @param {ProcName} procName The name of the procedure.
+   * @param {Procedure<T['state'], Ty, I, O, E, Init>} procDef The definition of the procedure.
+   * @returns {ServiceBuilder<{ name: T['name']; state: T['state']; procedures: T['procedures'] & { [k in ProcName]: Procedure<T['state'], Ty, I, O, E, Init>; }; }>} A new ServiceBuilder instance with the updated schema.
+   */
+  defineProcedure(procName, procDef) {
+    const newProcedure = { [procName]: procDef };
+    const procedures = {
+      ...this.schema.procedures,
+      ...newProcedure
+    };
+    return new _ServiceBuilder({
+      ...this.schema,
+      procedures
+    });
+  }
+  /**
+   * Creates a new instance of ServiceBuilder.
+   * @param {Name} name The name of the service.
+   * @returns {ServiceBuilder<{ name: Name; state: {}; procedures: {}; }>} A new instance of ServiceBuilder.
+   */
+  static create(name) {
+    return new _ServiceBuilder({
+      name,
+      state: {},
+      procedures: {}
+    });
+  }
+};
+
+// router/defs.ts
+function buildServiceDefs(services) {
+  return services.reduce((acc, service) => {
+    acc[service.name] = service;
+    return acc;
+  }, {});
+}
+
+// router/client.ts
+import { pushable } from "it-pushable";
+import { nanoid } from "nanoid";
+
+// router/result.ts
+import {
+  Type as Type2
+} from "@sinclair/typebox";
+var UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT = "UNEXPECTED_DISCONNECT";
+var RiverUncaughtSchema = Type2.Object({
+  code: Type2.Union([
+    Type2.Literal(UNCAUGHT_ERROR),
+    Type2.Literal(UNEXPECTED_DISCONNECT)
+  ]),
+  message: Type2.String()
+});
+function Ok(payload) {
+  return {
+    ok: true,
+    payload
+  };
+}
+function Err(error) {
+  return {
+    ok: false,
+    payload: error
+  };
+}
+
+// router/client.ts
+var noop = () => {
+};
+function _createRecursiveProxy(callback, path) {
+  const proxy = new Proxy(noop, {
+    // property access, recurse and add field to path
+    get(_obj, key) {
+      if (typeof key !== "string")
+        return void 0;
+      return _createRecursiveProxy(callback, [...path, key]);
+    },
+    // hit the end, let's invoke the handler
+    apply(_target, _this, args) {
+      return callback({
+        path,
+        args
+      });
+    }
+  });
+  return proxy;
+}
+var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(async (opts) => {
+  const [serviceName, procName, procType] = [...opts.path];
+  if (!(serviceName && procName && procType)) {
+    throw new Error(
+      "invalid river call, ensure the service and procedure you are calling exists"
+    );
+  }
+  const [input] = opts.args;
+  if (procType === "rpc") {
+    return handleRpc(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else if (procType === "stream") {
+    return handleStream(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else if (procType === "subscribe") {
+    return handleSubscribe(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else if (procType === "upload") {
+    return handleUpload(
+      transport,
+      serverId,
+      input,
+      serviceName,
+      procName
+    );
+  } else {
+    throw new Error(`invalid river call, unknown procedure type ${procType}`);
+  }
+}, []);
+var CONNECTION_GRACE_PERIOD_MS = 5e3;
+function rejectAfterDisconnectGrace(from, cb) {
+  let timeout = void 0;
+  return (evt) => {
+    if (evt.status === "connect" && evt.conn.connectedTo === from) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+    if (evt.status === "disconnect" && evt.conn.connectedTo === from) {
+      timeout = setTimeout(cb, CONNECTION_GRACE_PERIOD_MS);
+    }
+  };
+}
+function handleRpc(transport, serverId, input, serviceName, procName) {
+  const streamId = nanoid();
+  const m = msg(
+    transport.clientId,
+    serverId,
+    streamId,
+    input,
+    serviceName,
+    procName
+  );
+  m.controlFlags |= 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */;
+  transport.send(m);
+  const responsePromise = new Promise((resolve) => {
+    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+      cleanup();
+      resolve(
+        Err({
+          code: UNEXPECTED_DISCONNECT,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    });
+    function cleanup() {
+      transport.removeEventListener("message", onMessage);
+      transport.removeEventListener("connectionStatus", onConnectionStatus);
+    }
+    function onMessage(msg2) {
+      if (msg2.streamId === streamId) {
+        cleanup();
+        resolve(msg2.payload);
+      }
+    }
+    transport.addEventListener("message", onMessage);
+    transport.addEventListener("connectionStatus", onConnectionStatus);
+  });
+  return responsePromise;
+}
+function handleStream(transport, serverId, init, serviceName, procName) {
+  const streamId = nanoid();
+  const inputStream = pushable({ objectMode: true });
+  const outputStream = pushable({ objectMode: true });
+  let firstMessage = true;
+  if (init) {
+    const m = msg(
+      transport.clientId,
+      serverId,
+      streamId,
+      init,
+      serviceName,
+      procName
+    );
+    m.controlFlags = 2 /* StreamOpenBit */;
+    transport.send(m);
+    firstMessage = false;
+  }
+  (async () => {
+    for await (const rawIn of inputStream) {
+      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      if (firstMessage) {
+        m.serviceName = serviceName;
+        m.procedureName = procName;
+        m.controlFlags |= 2 /* StreamOpenBit */;
+        firstMessage = false;
+      }
+      transport.send(m);
+    }
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  })();
+  function onMessage(msg2) {
+    if (msg2.streamId !== streamId) {
+      return;
+    }
+    if (isStreamClose(msg2.controlFlags)) {
+      cleanup();
+    } else {
+      outputStream.push(msg2.payload);
+    }
+  }
+  function cleanup() {
+    inputStream.end();
+    outputStream.end();
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("connectionStatus", onConnectionStatus);
+  }
+  const closeHandler = () => {
+    cleanup();
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  };
+  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    outputStream.push(
+      Err({
+        code: UNEXPECTED_DISCONNECT,
+        message: `${serverId} unexpectedly disconnected`
+      })
+    );
+    cleanup();
+  });
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("connectionStatus", onConnectionStatus);
+  return [inputStream, outputStream, closeHandler];
+}
+function handleSubscribe(transport, serverId, input, serviceName, procName) {
+  const streamId = nanoid();
+  const m = msg(
+    transport.clientId,
+    serverId,
+    streamId,
+    input,
+    serviceName,
+    procName
+  );
+  m.controlFlags |= 2 /* StreamOpenBit */;
+  transport.send(m);
+  const outputStream = pushable({ objectMode: true });
+  function onMessage(msg2) {
+    if (msg2.streamId !== streamId) {
+      return;
+    }
+    if (isStreamClose(msg2.controlFlags)) {
+      cleanup();
+    } else {
+      outputStream.push(msg2.payload);
+    }
+  }
+  function cleanup() {
+    outputStream.end();
+    transport.removeEventListener("message", onMessage);
+    transport.removeEventListener("connectionStatus", onConnectionStatus);
+  }
+  const closeHandler = () => {
+    cleanup();
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  };
+  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    outputStream.push(
+      Err({
+        code: UNEXPECTED_DISCONNECT,
+        message: `${serverId} unexpectedly disconnected`
+      })
+    );
+    cleanup();
+  });
+  transport.addEventListener("message", onMessage);
+  transport.addEventListener("connectionStatus", onConnectionStatus);
+  return [outputStream, closeHandler];
+}
+function handleUpload(transport, serverId, input, serviceName, procName) {
+  const streamId = nanoid();
+  const inputStream = pushable({ objectMode: true });
+  let firstMessage = true;
+  if (input) {
+    const m = msg(
+      transport.clientId,
+      serverId,
+      streamId,
+      input,
+      serviceName,
+      procName
+    );
+    m.controlFlags = 2 /* StreamOpenBit */;
+    transport.send(m);
+    firstMessage = false;
+  }
+  (async () => {
+    for await (const rawIn of inputStream) {
+      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      if (firstMessage) {
+        m.controlFlags |= 2 /* StreamOpenBit */;
+        m.serviceName = serviceName;
+        m.procedureName = procName;
+        firstMessage = false;
+      }
+      transport.send(m);
+    }
+    transport.send(closeStream(transport.clientId, serverId, streamId));
+  })();
+  const responsePromise = new Promise((resolve) => {
+    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+      cleanup();
+      resolve(
+        Err({
+          code: UNEXPECTED_DISCONNECT,
+          message: `${serverId} unexpectedly disconnected`
+        })
+      );
+    });
+    function cleanup() {
+      inputStream.end();
+      transport.removeEventListener("message", onMessage);
+      transport.removeEventListener("connectionStatus", onConnectionStatus);
+    }
+    function onMessage(msg2) {
+      if (msg2.streamId === streamId) {
+        cleanup();
+        resolve(msg2.payload);
+      }
+    }
+    transport.addEventListener("message", onMessage);
+    transport.addEventListener("connectionStatus", onConnectionStatus);
+  });
+  return [inputStream, responsePromise];
+}
+
+// router/server.ts
+import { pushable as pushable2 } from "it-pushable";
+import { Value } from "@sinclair/typebox/value";
+var RiverServer = class {
+  transport;
+  services;
+  contextMap;
+  // map of streamId to ProcStream
+  streamMap;
+  // map of client to their open streams by streamId
+  clientStreams;
+  constructor(transport, services, extendedContext) {
+    this.transport = transport;
+    this.services = services;
+    this.contextMap = /* @__PURE__ */ new Map();
+    for (const service of Object.values(services)) {
+      this.contextMap.set(service, {
+        ...extendedContext,
+        state: service.state
+      });
+    }
+    this.streamMap = /* @__PURE__ */ new Map();
+    this.clientStreams = /* @__PURE__ */ new Map();
+    this.transport.addEventListener("message", this.handler);
+    this.transport.addEventListener("connectionStatus", this.onDisconnect);
+  }
+  get streams() {
+    return this.streamMap;
+  }
+  handler = async (message) => {
+    if (message.to !== this.transport.clientId) {
+      log?.info(
+        `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
+      );
+      return;
+    }
+    let procStream = this.streamMap.get(message.streamId);
+    const isInitMessage = !procStream;
+    procStream ||= this.createNewProcStream(message);
+    if (!procStream) {
+      return;
+    }
+    await this.pushToStream(procStream, message, isInitMessage);
+  };
+  // cleanup streams on unexpected disconnections
+  onDisconnect = async (evt) => {
+    if (evt.status !== "disconnect") {
+      return;
+    }
+    const disconnectedClientId = evt.conn.connectedTo;
+    log?.info(
+      `${this.transport.clientId} -- got unexpected disconnect from ${disconnectedClientId}, cleaning up streams`
+    );
+    const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
+    if (!streamsFromThisClient) {
+      return;
+    }
+    await Promise.all(
+      Array.from(streamsFromThisClient).map(this.cleanupStream)
+    );
+    this.clientStreams.delete(disconnectedClientId);
+  };
+  async close() {
+    this.transport.removeEventListener("message", this.handler);
+    this.transport.removeEventListener("connectionStatus", this.onDisconnect);
+    await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
+  }
+  createNewProcStream(message) {
+    if (!isStreamOpen(message.controlFlags)) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find a matching procedure stream for ${message.serviceName}.${message.procedureName}:${message.streamId}`
+      );
+      return;
+    }
+    if (!message.serviceName || !(message.serviceName in this.services)) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
+      );
+      return;
+    }
+    const service = this.services[message.serviceName];
+    const serviceContext = this.getContext(service);
+    if (!message.procedureName || !(message.procedureName in service.procedures)) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
+      );
+      return;
+    }
+    const procedure = service.procedures[message.procedureName];
+    const incoming = pushable2({ objectMode: true });
+    const outgoing = pushable2({ objectMode: true });
+    const outputHandler = (
+      // sending outgoing messages back to client
+      (async () => {
+        for await (const response of outgoing) {
+          this.transport.send(reply(message, response));
+        }
+        if (procedure.type === "subscription" || procedure.type === "stream") {
+          this.transport.send(
+            closeStream(
+              this.transport.clientId,
+              message.from,
+              message.streamId
+            )
+          );
+        }
+      })()
+    );
+    const errorHandler = (err) => {
+      const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
+      log?.error(
+        `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`
+      );
+      outgoing.push(
+        Err({
+          code: UNCAUGHT_ERROR,
+          message: errorMsg
+        })
+      );
+    };
+    let inputHandler;
+    const procHasInitMessage = "init" in procedure;
+    if (procedure.type === "stream") {
+      if (procHasInitMessage) {
+        inputHandler = (async () => {
+          const initMessage = await incoming.next();
+          if (initMessage.done) {
+            return;
+          }
+          return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+        })();
+      } else {
+        inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+      }
+    } else if (procedure.type === "rpc") {
+      inputHandler = (async () => {
+        const inputMessage = await incoming.next();
+        if (inputMessage.done) {
+          return;
+        }
+        try {
+          const outputMessage = await procedure.handler(
+            serviceContext,
+            inputMessage.value
+          );
+          outgoing.push(outputMessage);
+        } catch (err) {
+          errorHandler(err);
+        }
+      })();
+    } else if (procedure.type === "subscription") {
+      inputHandler = (async () => {
+        const inputMessage = await incoming.next();
+        if (inputMessage.done) {
+          return;
+        }
+        try {
+          await procedure.handler(serviceContext, inputMessage.value, outgoing);
+        } catch (err) {
+          errorHandler(err);
+        }
+      })();
+    } else if (procedure.type === "upload") {
+      if (procHasInitMessage) {
+        inputHandler = (async () => {
+          const initMessage = await incoming.next();
+          if (initMessage.done) {
+            return;
+          }
+          try {
+            const outputMessage = await procedure.handler(
+              serviceContext,
+              initMessage.value,
+              incoming
+            );
+            outgoing.push(outputMessage);
+          } catch (err) {
+            errorHandler(err);
+          }
+        })();
+      } else {
+        inputHandler = (async () => {
+          try {
+            const outputMessage = await procedure.handler(
+              serviceContext,
+              incoming
+            );
+            outgoing.push(outputMessage);
+          } catch (err) {
+            errorHandler(err);
+          }
+        })();
+      }
+    } else {
+      log?.warn(
+        `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+      );
+      return;
+    }
+    const procStream = {
+      id: message.streamId,
+      incoming,
+      outgoing,
+      serviceName: message.serviceName,
+      procedureName: message.procedureName,
+      procedure,
+      promises: { inputHandler, outputHandler }
+    };
+    this.streamMap.set(message.streamId, procStream);
+    const streamsFromThisClient = this.clientStreams.get(message.from) ?? /* @__PURE__ */ new Set();
+    streamsFromThisClient.add(message.streamId);
+    this.clientStreams.set(message.from, streamsFromThisClient);
+    return procStream;
+  }
+  async pushToStream(procStream, message, isInit) {
+    const procedure = procStream.procedure;
+    const procHasInitMessage = "init" in procedure;
+    if (isInit && procHasInitMessage && Value.Check(procedure.init, message.payload) || Value.Check(procedure.input, message.payload)) {
+      procStream.incoming.push(message.payload);
+    } else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
+      log?.error(
+        `${this.transport.clientId} -- procedure ${procStream.serviceName}.${procStream.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`
+      );
+    }
+    if (isStreamClose(message.controlFlags)) {
+      await this.cleanupStream(message.streamId);
+      const streamsFromThisClient = this.clientStreams.get(message.from);
+      if (streamsFromThisClient) {
+        streamsFromThisClient.delete(message.streamId);
+        if (streamsFromThisClient.size === 0) {
+          this.clientStreams.delete(message.from);
+        }
+      }
+    }
+  }
+  getContext(service) {
+    const context = this.contextMap.get(service);
+    if (!context) {
+      const err = `${this.transport.clientId} -- no context found for ${service.name}`;
+      log?.error(err);
+      throw new Error(err);
+    }
+    return context;
+  }
+  cleanupStream = async (id) => {
+    const stream = this.streamMap.get(id);
+    if (!stream) {
+      return;
+    }
+    stream.incoming.end();
+    await stream.promises.inputHandler;
+    stream.outgoing.end();
+    await stream.promises.outputHandler;
+    this.streamMap.delete(id);
+  };
+};
+function createServer(transport, services, extendedContext) {
+  return new RiverServer(transport, services, extendedContext);
+}
+
+export {
+  serializeService,
+  ServiceBuilder,
+  buildServiceDefs,
+  UNCAUGHT_ERROR,
+  RiverUncaughtSchema,
+  Ok,
+  Err,
+  createClient,
+  createServer
+};