better-sse 0.14.0 → 0.15.0

package/build/index.js

@@ -26,15 +26,62 @@ __export(src_exports, {
   SseError: () => SseError,
   createChannel: () => createChannel,
   createEventBuffer: () => createEventBuffer,
+  createResponse: () => createResponse,
   createSession: () => createSession
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/Session.ts
-var import_http = require("http");
+var import_node_http = require("http");
+var import_node_http2 = require("http2");
+var import_node_timers = require("timers");
 
-// src/lib/serialize.ts
-var serialize = (data) => JSON.stringify(data);
+// src/lib/createPushFromIterable.ts
+var createPushFromIterable = (push) => async (iterable, options = {}) => {
+  const { eventName = "iteration" } = options;
+  for await (const data of iterable) {
+    push(data, eventName);
+  }
+};
+
+// src/lib/createPushFromStream.ts
+var import_node_stream = require("stream");
+var createPushFromStream = (push) => async (stream, options = {}) => {
+  const { eventName = "stream" } = options;
+  if (stream instanceof import_node_stream.Readable) {
+    return await new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => {
+        let data;
+        if (Buffer.isBuffer(chunk)) {
+          data = chunk.toString();
+        } else {
+          data = chunk;
+        }
+        push(data, eventName);
+      });
+      stream.once("end", () => resolve(true));
+      stream.once("close", () => resolve(true));
+      stream.once("error", (err) => reject(err));
+    });
+  }
+  for await (const chunk of stream) {
+    if (Buffer.isBuffer(chunk)) {
+      push(chunk.toString(), eventName);
+    } else {
+      push(chunk, eventName);
+    }
+  }
+  return true;
+};
+
+// src/lib/generateId.ts
+var import_node_crypto = require("crypto");
+var generateId;
+if (import_node_crypto.randomUUID) {
+  generateId = () => (0, import_node_crypto.randomUUID)();
+} else {
+  generateId = () => (0, import_node_crypto.randomBytes)(4).toString("hex");
+}
 
 // src/lib/sanitize.ts
 var newlineVariantsRegex = /(\r\n|\r|\n)/g;
@@ -46,41 +93,8 @@ var sanitize = (text) => {
   return sanitized;
 };
 
-// src/lib/generateId.ts
-var import_crypto = require("crypto");
-var generateId;
-if (import_crypto.randomUUID) {
-  generateId = () => (0, import_crypto.randomUUID)();
-} else {
-  generateId = () => (0, import_crypto.randomBytes)(4).toString("hex");
-}
-
-// src/lib/createPushFromStream.ts
-var createPushFromStream = (push) => async (stream, options = {}) => {
-  const { eventName = "stream" } = options;
-  return await new Promise((resolve, reject) => {
-    stream.on("data", (chunk) => {
-      let data;
-      if (Buffer.isBuffer(chunk)) {
-        data = chunk.toString();
-      } else {
-        data = chunk;
-      }
-      push(data, eventName);
-    });
-    stream.once("end", () => resolve(true));
-    stream.once("close", () => resolve(true));
-    stream.once("error", (err) => reject(err));
-  });
-};
-
-// src/lib/createPushFromIterable.ts
-var createPushFromIterable = (push) => async (iterable, options = {}) => {
-  const { eventName = "iteration" } = options;
-  for await (const data of iterable) {
-    push(data, eventName);
-  }
-};
+// src/lib/serialize.ts
+var serialize = (data) => JSON.stringify(data);
 
 // src/EventBuffer.ts
 var EventBuffer = class {
@@ -214,9 +228,181 @@ var EventBuffer = class {
   read = () => this.buffer;
 };
 
+// src/lib/applyHeaders.ts
+var applyHeaders = (from, to) => {
+  const fromMap = from instanceof Headers ? Object.fromEntries(from) : from;
+  for (const [key, value] of Object.entries(fromMap)) {
+    if (Array.isArray(value)) {
+      to.delete(key);
+      for (const item of value) {
+        to.append(key, item);
+      }
+    } else if (value === void 0) {
+      to.delete(key);
+    } else {
+      to.set(key, value);
+    }
+  }
+};
+
+// src/lib/constants.ts
+var DEFAULT_REQUEST_HOST = "localhost";
+var DEFAULT_REQUEST_METHOD = "GET";
+var DEFAULT_RESPONSE_CODE = 200;
+var DEFAULT_RESPONSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "private, no-cache, no-store, no-transform, must-revalidate, max-age=0",
+  Connection: "keep-alive",
+  Pragma: "no-cache",
+  "X-Accel-Buffering": "no"
+};
+
+// src/adapters/FetchConnection.ts
+var FetchConnection = class _FetchConnection {
+  static encoder = new TextEncoder();
+  writer;
+  url;
+  request;
+  response;
+  constructor(request, response, options = {}) {
+    this.url = new URL(request.url);
+    this.request = request;
+    const { readable, writable } = new TransformStream();
+    this.writer = writable.getWriter();
+    this.response = new Response(readable, {
+      status: options.statusCode ?? response?.status ?? DEFAULT_RESPONSE_CODE,
+      headers: DEFAULT_RESPONSE_HEADERS
+    });
+    if (response) {
+      applyHeaders(response.headers, this.response.headers);
+    }
+  }
+  sendHead = () => {
+  };
+  sendChunk = (chunk) => {
+    const encoded = _FetchConnection.encoder.encode(chunk);
+    this.writer.write(encoded);
+  };
+  cleanup = () => {
+    this.writer.close();
+  };
+};
+
+// src/adapters/NodeHttp1Connection.ts
+var NodeHttp1Connection = class {
+  constructor(req, res, options = {}) {
+    this.req = req;
+    this.res = res;
+    this.url = new URL(
+      `http://${req.headers.host ?? DEFAULT_REQUEST_HOST}${req.url}`
+    );
+    this.controller = new AbortController();
+    req.once("close", this.onClose);
+    res.once("close", this.onClose);
+    this.request = new Request(this.url, {
+      method: req.method ?? DEFAULT_REQUEST_METHOD,
+      signal: this.controller.signal
+    });
+    applyHeaders(req.headers, this.request.headers);
+    this.response = new Response(null, {
+      status: options.statusCode ?? res.statusCode ?? DEFAULT_RESPONSE_CODE,
+      headers: DEFAULT_RESPONSE_HEADERS
+    });
+    if (res) {
+      applyHeaders(
+        res.getHeaders(),
+        this.response.headers
+      );
+    }
+  }
+  controller;
+  url;
+  request;
+  response;
+  onClose = () => {
+    this.controller.abort();
+  };
+  sendHead = () => {
+    this.res.writeHead(
+      this.response.status,
+      Object.fromEntries(this.response.headers)
+    );
+  };
+  sendChunk = (chunk) => {
+    this.res.write(chunk);
+  };
+  cleanup = () => {
+    this.req.removeListener("close", this.onClose);
+    this.res.removeListener("close", this.onClose);
+  };
+};
+
+// src/adapters/NodeHttp2CompatConnection.ts
+var NodeHttp2CompatConnection = class {
+  constructor(req, res, options = {}) {
+    this.req = req;
+    this.res = res;
+    this.url = new URL(
+      `http://${req.headers.host ?? DEFAULT_REQUEST_HOST}${req.url}`
+    );
+    this.controller = new AbortController();
+    req.once("close", this.onClose);
+    res.once("close", this.onClose);
+    this.request = new Request(this.url, {
+      method: req.method ?? DEFAULT_REQUEST_METHOD,
+      signal: this.controller.signal
+    });
+    const allowedHeaders = { ...req.headers };
+    for (const header of Object.keys(allowedHeaders)) {
+      if (header.startsWith(":")) {
+        delete allowedHeaders[header];
+      }
+    }
+    applyHeaders(allowedHeaders, this.request.headers);
+    this.response = new Response(null, {
+      status: options.statusCode ?? res.statusCode ?? DEFAULT_RESPONSE_CODE,
+      headers: DEFAULT_RESPONSE_HEADERS
+    });
+    if (res) {
+      applyHeaders(
+        res.getHeaders(),
+        this.response.headers
+      );
+    }
+  }
+  controller;
+  url;
+  request;
+  response;
+  onClose = () => {
+    this.controller.abort();
+  };
+  sendHead = () => {
+    this.res.writeHead(
+      this.response.status,
+      Object.fromEntries(this.response.headers)
+    );
+  };
+  sendChunk = (chunk) => {
+    this.res.write(chunk);
+  };
+  cleanup = () => {
+    this.req.removeListener("close", this.onClose);
+    this.res.removeListener("close", this.onClose);
+  };
+};
+
+// src/lib/SseError.ts
+var SseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.message = `better-sse: ${message}`;
+  }
+};
+
 // src/lib/TypedEmitter.ts
-var import_events = require("events");
-var TypedEmitter = class extends import_events.EventEmitter {
+var import_node_events = require("events");
+var TypedEmitter = class extends import_node_events.EventEmitter {
   addListener(event, listener) {
     return super.addListener(event, listener);
   }
@@ -243,14 +429,6 @@ var TypedEmitter = class extends import_events.EventEmitter {
   }
 };
 
-// src/lib/SseError.ts
-var SseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.message = `better-sse: ${message}`;
-  }
-};
-
 // src/Session.ts
 var Session = class extends TypedEmitter {
   /**
@@ -279,70 +457,78 @@ var Session = class extends TypedEmitter {
    */
   state;
   buffer;
-  /**
-   * Raw HTTP request.
-   */
-  req;
-  /**
-   * Raw HTTP response that is the minimal interface needed and forms the
-   * intersection between the HTTP/1.1 and HTTP/2 server response interfaces.
-   */
-  res;
-  serialize;
+  connection;
   sanitize;
-  trustClientEventId;
+  serialize;
   initialRetry;
   keepAliveInterval;
   keepAliveTimer;
-  statusCode;
-  headers;
-  constructor(req, res, options = {}) {
+  constructor(req, res, options) {
     super();
-    this.req = req;
-    this.res = res;
-    const serializer = options.serializer ?? serialize;
-    const sanitizer = options.sanitizer ?? sanitize;
-    this.serialize = serializer;
-    this.sanitize = sanitizer;
-    this.buffer = new EventBuffer({ serializer, sanitizer });
-    this.trustClientEventId = options.trustClientEventId ?? true;
-    this.initialRetry = options.retry === null ? null : options.retry ?? 2e3;
-    this.keepAliveInterval = options.keepAlive === null ? null : options.keepAlive ?? 1e4;
-    this.statusCode = options.statusCode ?? 200;
-    this.headers = options.headers ?? {};
-    this.state = options.state ?? {};
-    this.req.once("close", this.onDisconnected);
-    this.res.once("close", this.onDisconnected);
-    setImmediate(this.initialize);
-  }
-  initialize = () => {
-    const url = `http://${this.req.headers.host}${this.req.url}`;
-    const params = new URL(url).searchParams;
-    if (this.trustClientEventId) {
-      const givenLastEventId = this.req.headers["last-event-id"] ?? params.get("lastEventId") ?? params.get("evs_last_event_id") ?? "";
-      this.lastId = givenLastEventId;
-    }
-    const headers = {};
-    if (this.res instanceof import_http.ServerResponse) {
-      headers["Content-Type"] = "text/event-stream";
-      headers["Cache-Control"] = "private, no-cache, no-store, no-transform, must-revalidate, max-age=0";
-      headers["Connection"] = "keep-alive";
-      headers["Pragma"] = "no-cache";
-      headers["X-Accel-Buffering"] = "no";
+    let givenOptions = options ?? {};
+    if (req instanceof Request) {
+      let givenRes = null;
+      if (res) {
+        if (res instanceof Response) {
+          givenRes = res;
+        } else {
+          if (options) {
+            throw new SseError(
+              "When providing a Fetch Request object but no Response object, you may pass options as the second OR third argument to the session constructor, but not to both."
+            );
+          }
+          givenOptions = res;
+        }
+      }
+      this.connection = new FetchConnection(req, givenRes, givenOptions);
+    } else if (req instanceof import_node_http.IncomingMessage) {
+      if (res instanceof import_node_http.ServerResponse) {
+        this.connection = new NodeHttp1Connection(req, res, givenOptions);
+      } else {
+        throw new SseError(
+          "When providing a Node IncomingMessage object, a corresponding ServerResponse object must also be provided."
+        );
+      }
+    } else if (req instanceof import_node_http2.Http2ServerRequest) {
+      if (res instanceof import_node_http2.Http2ServerResponse) {
+        this.connection = new NodeHttp2CompatConnection(req, res, givenOptions);
+      } else {
+        throw new SseError(
+          "When providing a Node HTTP2ServerRequest object, a corresponding HTTP2ServerResponse object must also be provided."
+        );
+      }
     } else {
-      headers["content-type"] = "text/event-stream";
-      headers["cache-control"] = "private, no-cache, no-store, no-transform, must-revalidate, max-age=0";
-      headers["pragma"] = "no-cache";
-      headers["x-accel-buffering"] = "no";
+      throw new SseError(
+        "Malformed request or response objects given to session constructor. Must be one of IncomingMessage/ServerResponse from the Node HTTP/1 API, HTTP2ServerRequest/HTTP2ServerResponse from the Node HTTP/2 Compatibility API, or Request/Response from the Fetch API."
+      );
+    }
+    if (givenOptions.headers) {
+      applyHeaders(givenOptions.headers, this.connection.response.headers);
     }
-    for (const [name, value] of Object.entries(this.headers)) {
-      headers[name] = value ?? "";
+    if (givenOptions.trustClientEventId !== false) {
+      this.lastId = this.connection.request.headers.get("last-event-id") ?? this.connection.url.searchParams.get("lastEventId") ?? this.connection.url.searchParams.get("evs_last_event_id") ?? "";
     }
-    this.res.writeHead(this.statusCode, headers);
-    if (params.has("padding")) {
+    this.state = givenOptions.state ?? {};
+    this.initialRetry = givenOptions.retry === null ? null : givenOptions.retry ?? 2e3;
+    this.keepAliveInterval = givenOptions.keepAlive === null ? null : givenOptions.keepAlive ?? 1e4;
+    this.serialize = givenOptions.serializer ?? serialize;
+    this.sanitize = givenOptions.sanitizer ?? sanitize;
+    this.buffer = new EventBuffer({
+      serializer: this.serialize,
+      sanitizer: this.sanitize
+    });
+    this.connection.request.signal.addEventListener(
+      "abort",
+      this.onDisconnected
+    );
+    (0, import_node_timers.setImmediate)(this.initialize);
+  }
+  initialize = () => {
+    this.connection.sendHead();
+    if (this.connection.url.searchParams.has("padding")) {
       this.buffer.comment(" ".repeat(2049)).dispatch();
     }
-    if (params.has("evs_preamble")) {
+    if (this.connection.url.searchParams.has("evs_preamble")) {
       this.buffer.comment(" ".repeat(2056)).dispatch();
     }
     if (this.initialRetry !== null) {
@@ -350,80 +536,57 @@ var Session = class extends TypedEmitter {
     }
     this.flush();
     if (this.keepAliveInterval !== null) {
-      this.keepAliveTimer = setInterval(
-        this.keepAlive,
-        this.keepAliveInterval
-      );
+      this.keepAliveTimer = setInterval(this.keepAlive, this.keepAliveInterval);
     }
     this.isConnected = true;
     this.emit("connected");
   };
   onDisconnected = () => {
-    this.req.removeListener("close", this.onDisconnected);
-    this.res.removeListener("close", this.onDisconnected);
+    this.connection.request.signal.removeEventListener(
+      "abort",
+      this.onDisconnected
+    );
+    this.connection.cleanup();
     if (this.keepAliveTimer) {
       clearInterval(this.keepAliveTimer);
     }
     this.isConnected = false;
     this.emit("disconnected");
   };
+  /**
+   * Write an empty comment and flush it to the client.
+   */
   keepAlive = () => {
     this.buffer.comment().dispatch();
     this.flush();
   };
   /**
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
-   */
-  event(type) {
-    this.buffer.event(type);
-    return this;
-  }
-  /**
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
-   */
-  data = (data) => {
-    this.buffer.data(data);
-    return this;
-  };
-  /**
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
-   */
-  id = (id = "") => {
-    this.buffer.id(id);
-    this.lastId = id;
-    return this;
-  };
-  /**
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
-   */
-  retry = (time) => {
-    this.buffer.retry(time);
-    return this;
-  };
-  /**
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
+   * Flush the contents of the internal buffer to the client and clear the buffer.
    */
-  comment = (text) => {
-    this.buffer.comment(text);
-    return this;
+  flush = () => {
+    const contents = this.buffer.read();
+    this.buffer.clear();
+    this.connection.sendChunk(contents);
   };
   /**
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
+   * Get a Request object representing the request of the underlying connection this session manages.
+   *
+   * When using the Fetch API, this will be the original Request object passed to the session constructor.
+   *
+   * When using the Node HTTP APIs, this will be a new Request object with status code and headers copied from the original request.
+   * When the originally given request or response is closed, the abort signal attached to this Request will be triggered.
    */
-  dispatch = () => {
-    this.buffer.dispatch();
-    return this;
-  };
+  getRequest = () => this.connection.request;
   /**
-   * Flush the contents of the internal buffer to the client and clear the buffer.
+   * Get a Response object representing the response of the underlying connection this session manages.
+   *
+   * When using the Fetch API, this will be a new Response object with status code and headers copied from the original response if given.
+   * Its body will be a ReadableStream that should begin being consumed for the session to consider itself connected.
    *
-   * @deprecated see https://github.com/MatthewWid/better-sse/issues/52
+   * When using the Node HTTP APIs, this will be a new Response object with status code and headers copied from the original response.
+   * Its body will be `null`, as data is instead written to the stream of the originally given response object.
    */
-  flush = () => {
-    this.res.write(this.buffer.read());
-    this.buffer.clear();
-    return this;
-  };
+  getResponse = () => this.connection.response;
   /**
    * Push an event to the client.
    *
@@ -431,6 +594,8 @@ var Session = class extends TypedEmitter {
    *
    * If no event ID is given, the event ID (and thus the `lastId` property) is set to a unique string generated using a cryptographic pseudorandom number generator.
    *
+   * If the session has disconnected, an `SseError` will be thrown.
+   *
    * Emits the `push` event with the given data, event name and event ID in that order.
    *
    * @param data - Data to write.
@@ -439,7 +604,9 @@ var Session = class extends TypedEmitter {
    */
   push = (data, eventName = "message", eventId = generateId()) => {
     if (!this.isConnected) {
-      throw new SseError("Cannot push data to a non-active session.");
+      throw new SseError(
+        "Cannot push data to a non-active session. Ensure the session is connected before attempting to push events. If using the Fetch API, the response stream must begin being consumed before the session is considered connected."
+      );
     }
     this.buffer.push(data, eventName, eventId);
     this.flush();
@@ -488,25 +655,54 @@ var Session = class extends TypedEmitter {
    */
   batch = async (batcher) => {
     if (batcher instanceof EventBuffer) {
-      this.res.write(batcher.read());
+      this.connection.sendChunk(batcher.read());
     } else {
       const buffer = new EventBuffer({
         serializer: this.serialize,
         sanitizer: this.sanitize
       });
       await batcher(buffer);
-      this.res.write(buffer.read());
+      this.connection.sendChunk(buffer.read());
     }
   };
 };
 
 // src/createSession.ts
-var createSession = (...args) => new Promise((resolve) => {
+function createSession(req, res, options) {
+  return new Promise((resolve) => {
+    const session = new Session(req, res, options);
+    if (req instanceof Request) {
+      resolve(session);
+    } else {
+      session.once("connected", () => {
+        resolve(session);
+      });
+    }
+  });
+}
+
+// src/createResponse.ts
+function createResponse(request, response, options, callback) {
+  const args = [request, response, options, callback];
+  let givenCallback;
+  for (let index = args.length - 1; index >= 0; --index) {
+    const arg = args.pop();
+    if (arg) {
+      givenCallback = arg;
+      break;
+    }
+  }
+  if (typeof givenCallback !== "function") {
+    throw new SseError(
+      "Last argument given to createResponse must be a callback function."
+    );
+  }
   const session = new Session(...args);
   session.once("connected", () => {
-    resolve(session);
+    givenCallback(session);
   });
-});
+  return session.getResponse();
+}
 
 // src/Channel.ts
 var Channel = class extends TypedEmitter {
@@ -606,5 +802,6 @@ var createEventBuffer = (...args) => new EventBuffer(...args);
   SseError,
   createChannel,
   createEventBuffer,
+  createResponse,
   createSession
 });