@jsenv/server 15.5.2 → 16.0.0

package/src/web_socket_response.js

@@ -0,0 +1,53 @@
+/**
+ * The standard ways to create a Response
+ * - new Response(body, init)
+ * - Response.json(data, init)
+ * Here we need a way to tell: I want to handle websocket
+ * to align with the style of new Response and Response.json to make it look as follow:
+ * ```js
+ * import { WebSocketResponse } from "@jsenv/server"
+ * new WebSocketResponse((websocket) => {
+ *   // do stuff with the websocket
+ * })
+ * ```
+ *
+ * But we don't really need a class so we are just returning a regular object under the hood
+ */
+
+export class WebSocketResponse {
+  constructor(
+    webSocketHandler,
+    {
+      status = 101,
+      statusText = status === 101 ? "Switching Protocols" : undefined,
+      headers,
+    } = {},
+  ) {
+    const webSocketResponse = {
+      status,
+      statusText,
+      headers,
+      body: {
+        websocket: webSocketHandler,
+      },
+    };
+    // eslint-disable-next-line no-constructor-return
+    return webSocketResponse;
+  }
+}
+
+export const isWebSocketResponse = (responseProperties) => {
+  return (
+    responseProperties.body &&
+    typeof responseProperties.body.websocket === "function"
+  );
+};
+
+export const getWebSocketHandler = (responseProperties) => {
+  const responseBody = responseProperties.body;
+  if (!responseBody) {
+    return undefined;
+  }
+  const webSocketHandler = responseBody.websocket;
+  return webSocketHandler;
+};

package/src/from_fetch_response.js

@@ -1,15 +0,0 @@
-export const fromFetchResponse = (fetchResponse) => {
-  const responseHeaders = {};
-  const headersToIgnore = ["connection"];
-  fetchResponse.headers.forEach((value, name) => {
-    if (!headersToIgnore.includes(name)) {
-      responseHeaders[name] = value;
-    }
-  });
-  return {
-    status: fetchResponse.status,
-    statusText: fetchResponse.statusText,
-    headers: responseHeaders,
-    body: fetchResponse.body, // node-fetch assumed
-  };
-};

package/src/interfacing_with_node/body.js

@@ -1,81 +0,0 @@
-import { createReadStream } from "node:fs";
-import { Readable, Stream, Writable } from "node:stream";
-
-import { isObservable, observableFromValue } from "./observable.js";
-import { observableFromNodeStream } from "./observable_from_node_stream.js";
-
-export const normalizeBodyMethods = (body) => {
-  if (isObservable(body)) {
-    return {
-      asObservable: () => body,
-      destroy: () => {},
-    };
-  }
-
-  if (isFileHandle(body)) {
-    return {
-      asObservable: () => fileHandleToObservable(body),
-      destroy: () => {
-        body.close();
-      },
-    };
-  }
-
-  if (isNodeStream(body)) {
-    return {
-      asObservable: () => observableFromNodeStream(body),
-      destroy: () => {
-        body.destroy();
-      },
-    };
-  }
-
-  return {
-    asObservable: () => observableFromValue(body),
-    destroy: () => {},
-  };
-};
-
-export const isFileHandle = (value) => {
-  return value && value.constructor && value.constructor.name === "FileHandle";
-};
-
-export const fileHandleToReadableStream = (fileHandle) => {
-  const fileReadableStream =
-    typeof fileHandle.createReadStream === "function"
-      ? fileHandle.createReadStream()
-      : createReadStream(
-          "/toto", // is it ok to pass a fake path like this?
-          {
-            fd: fileHandle.fd,
-            emitClose: true,
-            // autoClose: true
-          },
-        );
-  // I suppose it's required only when doing fs.createReadStream()
-  // and not fileHandle.createReadStream()
-  // fileReadableStream.on("end", () => {
-  //   fileHandle.close()
-  // })
-  return fileReadableStream;
-};
-
-const fileHandleToObservable = (fileHandle) => {
-  return observableFromNodeStream(fileHandleToReadableStream(fileHandle));
-};
-
-const isNodeStream = (value) => {
-  if (value === undefined) {
-    return false;
-  }
-
-  if (
-    value instanceof Stream ||
-    value instanceof Writable ||
-    value instanceof Readable
-  ) {
-    return true;
-  }
-
-  return false;
-};

package/src/interfacing_with_node/request_factory.js

@@ -1,125 +0,0 @@
-import { Abort } from "@jsenv/abort";
-import { headersFromObject } from "../internal/headersFromObject.js";
-import { observableFromNodeStream } from "./observable_from_node_stream.js";
-
-export const fromNodeRequest = (
-  nodeRequest,
-  { serverOrigin, signal, requestBodyLifetime },
-) => {
-  const handleRequestOperation = Abort.startOperation();
-  if (signal) {
-    handleRequestOperation.addAbortSignal(signal);
-  }
-  handleRequestOperation.addAbortSource((abort) => {
-    nodeRequest.once("close", abort);
-    return () => {
-      nodeRequest.removeListener("close", abort);
-    };
-  });
-
-  const headers = headersFromObject(nodeRequest.headers);
-  const body = observableFromNodeStream(nodeRequest, {
-    readableStreamLifetime: requestBodyLifetime,
-  });
-
-  let requestOrigin;
-  if (nodeRequest.upgrade) {
-    requestOrigin = serverOrigin;
-  } else if (nodeRequest.authority) {
-    requestOrigin = nodeRequest.connection.encrypted
-      ? `https://${nodeRequest.authority}`
-      : `http://${nodeRequest.authority}`;
-  } else if (nodeRequest.headers.host) {
-    requestOrigin = nodeRequest.connection.encrypted
-      ? `https://${nodeRequest.headers.host}`
-      : `http://${nodeRequest.headers.host}`;
-  } else {
-    requestOrigin = serverOrigin;
-  }
-
-  return Object.freeze({
-    signal: handleRequestOperation.signal,
-    http2: Boolean(nodeRequest.stream),
-    origin: requestOrigin,
-    ...getPropertiesFromResource({
-      resource: nodeRequest.url,
-      baseUrl: requestOrigin,
-    }),
-    method: nodeRequest.method,
-    headers,
-    body,
-  });
-};
-
-export const applyRedirectionToRequest = (
-  request,
-  { resource, pathname, ...rest },
-) => {
-  return {
-    ...request,
-    ...(resource
-      ? getPropertiesFromResource({
-          resource,
-          baseUrl: request.url,
-        })
-      : pathname
-        ? getPropertiesFromPathname({
-            pathname,
-            baseUrl: request.url,
-          })
-        : {}),
-    ...rest,
-  };
-};
-
-const getPropertiesFromResource = ({ resource, baseUrl }) => {
-  const urlObject = new URL(resource, baseUrl);
-  let pathname = urlObject.pathname;
-
-  return {
-    url: String(urlObject),
-    searchParams: urlObject.searchParams,
-    pathname,
-    resource,
-  };
-};
-
-const getPropertiesFromPathname = ({ pathname, baseUrl }) => {
-  return getPropertiesFromResource({
-    resource: `${pathname}${new URL(baseUrl).search}`,
-    baseUrl,
-  });
-};
-
-export const createPushRequest = (request, { signal, pathname, method }) => {
-  const pushRequest = Object.freeze({
-    ...request,
-    parent: request,
-    signal,
-    http2: true,
-    ...(pathname
-      ? getPropertiesFromPathname({
-          pathname,
-          baseUrl: request.url,
-        })
-      : {}),
-    method: method || request.method,
-    headers: getHeadersInheritedByPushRequest(request),
-    body: undefined,
-  });
-  return pushRequest;
-};
-
-const getHeadersInheritedByPushRequest = (request) => {
-  const headersInherited = { ...request.headers };
-  // mtime sent by the client in request headers concerns the main request
-  // Time remains valid for request to other resources so we keep it
-  // in child requests
-  // delete childHeaders["if-modified-since"]
-
-  // eTag sent by the client in request headers concerns the main request
-  // A request made to an other resource must not inherit the eTag
-  delete headersInherited["if-none-match"];
-
-  return headersInherited;
-};

package/src/readRequestBody.js

@@ -1,32 +0,0 @@
-export const readRequestBody = (request, { as = "string" } = {}) => {
-  return new Promise((resolve, reject) => {
-    const bufferArray = [];
-    request.body.subscribe({
-      error: reject,
-      next: (buffer) => {
-        bufferArray.push(buffer);
-      },
-      complete: () => {
-        const bodyAsBuffer = Buffer.concat(bufferArray);
-
-        if (as === "buffer") {
-          resolve(bodyAsBuffer);
-          return;
-        }
-
-        if (as === "string") {
-          const bodyAsString = bodyAsBuffer.toString();
-          resolve(bodyAsString);
-          return;
-        }
-
-        if (as === "json") {
-          const bodyAsString = bodyAsBuffer.toString();
-          const bodyAsJSON = JSON.parse(bodyAsString);
-          resolve(bodyAsJSON);
-          return;
-        }
-      },
-    });
-  });
-};

package/src/server_timing/timing_measure.js

@@ -1,26 +0,0 @@
-import { performance } from "node:perf_hooks";
-
-export const timeStart = (name) => {
-  // as specified in https://w3c.github.io/server-timing/#the-performanceservertiming-interface
-  // duration is a https://www.w3.org/TR/hr-time-2/#sec-domhighrestimestamp
-  const startTimestamp = performance.now();
-  const timeEnd = () => {
-    const endTimestamp = performance.now();
-    const timing = {
-      [name]: endTimestamp - startTimestamp,
-    };
-    return timing;
-  };
-  return timeEnd;
-};
-
-export const timeFunction = (name, fn) => {
-  const timeEnd = timeStart(name);
-  const returnValue = fn();
-  if (returnValue && typeof returnValue.then === "function") {
-    return returnValue.then((value) => {
-      return [timeEnd(), value];
-    });
-  }
-  return [timeEnd(), returnValue];
-};