@jsenv/server 15.5.3 → 16.0.0

package/src/internal/headers_composition.js

@@ -1,32 +1,59 @@
 import { composeTwoObjects } from "./object_composition.js";
 
 export const composeTwoHeaders = (firstHeaders, secondHeaders) => {
+  if (firstHeaders && typeof firstHeaders.entries === "function") {
+    firstHeaders = Object.fromEntries(firstHeaders.entries());
+  }
+  if (secondHeaders && typeof secondHeaders.entries === "function") {
+    secondHeaders = Object.fromEntries(secondHeaders.entries());
+  }
   return composeTwoObjects(firstHeaders, secondHeaders, {
     keysComposition: HEADER_NAMES_COMPOSITION,
     forceLowerCase: true,
   });
 };
 
-const composeHeaderValues = (value, nextValue) => {
-  const headerValues = value.split(", ");
-  nextValue.split(", ").forEach((value) => {
-    if (!headerValues.includes(value)) {
-      headerValues.push(value);
+export const composeTwoHeaderValues = (name, leftValue, rightValue) => {
+  if (HEADER_NAMES_COMPOSITION[name]) {
+    return HEADER_NAMES_COMPOSITION[name](leftValue, rightValue);
+  }
+  return rightValue;
+};
+
+const composeTwoCommaSeparatedValues = (value, nextValue) => {
+  if (!value) {
+    return nextValue;
+  }
+  if (!nextValue) {
+    return value;
+  }
+  const currentValues = value
+    .split(", ")
+    .map((part) => part.trim().toLowerCase());
+  const nextValues = nextValue
+    .split(", ")
+    .map((part) => part.trim().toLowerCase());
+  for (const nextValue of nextValues) {
+    if (!currentValues.includes(nextValue)) {
+      currentValues.push(nextValue);
     }
-  });
-  return headerValues.join(", ");
+  }
+  return currentValues.join(", ");
 };
 
 const HEADER_NAMES_COMPOSITION = {
-  "accept": composeHeaderValues,
-  "accept-charset": composeHeaderValues,
-  "accept-language": composeHeaderValues,
-  "access-control-allow-headers": composeHeaderValues,
-  "access-control-allow-methods": composeHeaderValues,
-  "access-control-allow-origin": composeHeaderValues,
+  "accept": composeTwoCommaSeparatedValues,
+  "accept-charset": composeTwoCommaSeparatedValues,
+  "accept-language": composeTwoCommaSeparatedValues,
+  "access-control-allow-headers": composeTwoCommaSeparatedValues,
+  "access-control-allow-methods": composeTwoCommaSeparatedValues,
+  "access-control-allow-origin": composeTwoCommaSeparatedValues,
+  "accept-patch": composeTwoCommaSeparatedValues,
+  "accept-post": composeTwoCommaSeparatedValues,
+  "allow": composeTwoCommaSeparatedValues,
   // https://www.w3.org/TR/server-timing/
   // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server-Timing
-  "server-timing": composeHeaderValues,
+  "server-timing": composeTwoCommaSeparatedValues,
   // 'content-type', // https://github.com/ninenines/cowboy/issues/1230
-  "vary": composeHeaderValues,
+  "vary": composeTwoCommaSeparatedValues,
 };

package/src/internal/multiple-header.js

@@ -25,29 +25,44 @@ export const parseMultipleHeader = (
     if (!nameValidation) {
       return;
     }
-
-    const properties = parseHeaderProperties(valueParts.slice(1), {
-      validateProperty,
-    });
+    const afterName = valueParts.slice(1);
+    const properties = parseHeaderProperties(afterName, { validateProperty });
     multipleHeader[name] = properties;
   });
   return multipleHeader;
 };
 
+export const parseSingleHeaderWithAttributes = (
+  string,
+  { validateAttribute = () => true } = {},
+) => {
+  const props = {};
+  const attributes = string.split(";");
+  for (const attr of attributes) {
+    let [name, value] = attr.split("=");
+    name = name.trim();
+    value = value.trim();
+    if (validateAttribute({ name, value })) {
+      props[name] = value;
+    }
+  }
+  return props;
+};
+
 const parseHeaderProperties = (headerProperties, { validateProperty }) => {
-  const properties = headerProperties.reduce((previous, valuePart) => {
-    const [propertyName, propertyValueString] = valuePart.split("=");
+  const properties = {};
+  for (const propertySource of headerProperties) {
+    const [propertyName, propertyValueString] = propertySource
+      .trim()
+      .split("=");
     const propertyValue = parseHeaderPropertyValue(propertyValueString);
     const property = { name: propertyName, value: propertyValue };
     const propertyValidation = validateProperty(property);
     if (!propertyValidation) {
-      return previous;
+      continue;
     }
-    return {
-      ...previous,
-      [property.name]: property.value,
-    };
-  }, {});
+    properties[propertyName] = propertyValue;
+  }
   return properties;
 };
 

package/src/internal/object_composition.js

@@ -23,7 +23,7 @@ const applyCaseSensitiveComposition = (
 ) => {
   if (strict) {
     const composed = {};
-    Object.keys(keysComposition).forEach((key) => {
+    for (const key of Object.keys(keysComposition)) {
       composed[key] = composeValueAtKey({
         firstObject,
         secondObject,
@@ -32,7 +32,7 @@ const applyCaseSensitiveComposition = (
         firstKey: keyExistsIn(key, firstObject) ? key : null,
         secondKey: keyExistsIn(key, secondObject) ? key : null,
       });
-    });
+    }
     return composed;
   }
 

package/src/internal/response_composition.js

@@ -1,7 +1,23 @@
 import { composeTwoHeaders } from "./headers_composition.js";
 import { composeTwoObjects } from "./object_composition.js";
 
+const asResponseProperties = (value) => {
+  if (value && value instanceof Response) {
+    return {
+      status: value.status,
+      statusText: value.statusText,
+      headers: Object.fromEntries(value.headers),
+      body: value.body,
+      bodyEncoding: value.bodyEncoding,
+    };
+  }
+  return value;
+};
+
 export const composeTwoResponses = (firstResponse, secondResponse) => {
+  firstResponse = asResponseProperties(firstResponse);
+  secondResponse = asResponseProperties(secondResponse);
+
   return composeTwoObjects(firstResponse, secondResponse, {
     keysComposition: RESPONSE_KEYS_COMPOSITION,
     strict: true,
@@ -15,7 +31,4 @@ const RESPONSE_KEYS_COMPOSITION = {
   headers: composeTwoHeaders,
   body: (prevBody, body) => body,
   bodyEncoding: (prevEncoding, encoding) => encoding,
-  timing: (prevTiming, timing) => {
-    return { ...prevTiming, ...timing };
-  },
 };

package/src/main.js

@@ -7,9 +7,7 @@
 // tslint:disable:ordered-imports
 
 export { startServer } from "./start_server.js";
-export { setupRoutes } from "./service_composition/routing.js";
-export { readRequestBody } from "./readRequestBody.js";
-export { fetchFileSystem } from "./fetch_filesystem.js";
+
 export {
   STOP_REASON_INTERNAL_ERROR,
   STOP_REASON_PROCESS_SIGHUP,
@@ -21,6 +19,19 @@ export {
 } from "./stopReasons.js";
 export { jsenvServiceErrorHandler } from "./services/error_handler/jsenv_service_error_handler.js";
 
+// filesystem
+export {
+  createFileSystemFetch,
+  fetchFileSystem,
+} from "./filesystem/fetch_filesystem.js";
+
+// webSocket
+export { WebSocketResponse } from "./web_socket_response.js";
+// long polling
+export { ProgressiveResponse } from "./progressive_response.js";
+// Server event (can be used to push events to clients that can be connected with WebSocket or EventSource)
+export { ServerEvents, LazyServerEvents } from "./server_events.js";
+
 // CORS
 export {
   jsenvServiceCORS,
@@ -28,12 +39,6 @@ export {
   jsenvAccessControlAllowedMethods,
 } from "./services/cors/jsenv_service_cors.js";
 
-// server timing
-export { timeFunction, timeStart } from "./server_timing/timing_measure.js";
-
-// SSE
-export { createSSERoom } from "./sse/sse_room.js";
-
 // content-negotiation
 export { pickContentType } from "./content_negotiation/pick_content_type.js";
 export { pickContentEncoding } from "./content_negotiation/pick_content_encoding.js";
@@ -41,8 +46,7 @@ export { pickContentLanguage } from "./content_negotiation/pick_content_language
 export { jsenvServiceResponseAcceptanceCheck } from "./services/response_acceptance_check/jsenv_service_response_acceptance_check.js";
 
 // others
-export { serveDirectory } from "./serve_directory.js";
-export { fromFetchResponse } from "./from_fetch_response.js";
+export { serveDirectory } from "./filesystem/serve_directory.js";
 export { composeTwoResponses } from "./internal/response_composition.js";
 export { jsenvServiceRequestAliases } from "./services/request_aliases/jsenv_service_request_aliases.js";
 export { findFreePort } from "./internal/listen.js";

package/src/progressive_response.js

@@ -0,0 +1,38 @@
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
+import { createObservable } from "./interfacing_with_node/observable.js";
+
+export class ProgressiveResponse {
+  constructor(responseBodyHandler, { status = 200, statusText, headers } = {}) {
+    const contentType = headers ? headers["content-type"] : "text/plain";
+    const progressiveResponse = {
+      status,
+      statusText,
+      headers,
+      body: createObservable(({ next, complete, addTeardown }) => {
+        // we must write something for fetch promise to resolve
+        // this is conform to HTTP spec where client expect body to starts writing
+        // before resolving response promise client side
+        if (CONTENT_TYPE.isTextual(contentType)) {
+          next("");
+        } else {
+          next(new Uint8Array());
+        }
+        const returnValue = responseBodyHandler({
+          write: (data) => {
+            next(data);
+          },
+          end: () => {
+            complete();
+          },
+        });
+        if (typeof returnValue === "function") {
+          addTeardown(() => {
+            returnValue();
+          });
+        }
+      }),
+    };
+    // eslint-disable-next-line no-constructor-return
+    return progressiveResponse;
+  }
+}

package/src/replace_placeholder_in_html.js

@@ -0,0 +1,12 @@
+export const replacePlaceholdersInHtml = (html, replacers) => {
+  return html.replace(/\$\{(\w+)\}/g, (match, name) => {
+    const replacer = replacers[name];
+    if (replacer === undefined) {
+      return match;
+    }
+    if (typeof replacer === "function") {
+      return replacer();
+    }
+    return replacer;
+  });
+};

package/src/request_body_handling.js

@@ -0,0 +1,22 @@
+export const pickRequestContentType = (request, acceptedContentTypeArray) => {
+  const requestBodyContentType = request.headers["content-type"];
+  if (!requestBodyContentType) {
+    return null;
+  }
+  for (const acceptedContentType of acceptedContentTypeArray) {
+    if (requestBodyContentType.includes(acceptedContentType)) {
+      return acceptedContentType;
+    }
+  }
+  return null;
+};
+
+export const createUnsupportedMediaTypeResponse = (
+  request,
+  acceptedContentTypeArray = [],
+) => {
+  return {
+    status: 415,
+    [`accept-${request.method}`]: acceptedContentTypeArray.join(", "),
+  };
+};