@weborigami/origami 0.6.16 → 0.7.0-beta.1

package/src/server/constructResponse.js

@@ -1,4 +1,6 @@
 import { extension, isPacked, toString, Tree } from "@weborigami/async-tree";
+import { symbols } from "@weborigami/language";
+import { createHash } from "node:crypto";
 import { computedMIMEType } from "whatwg-mimetype";
 import { mediaTypeForExtension } from "./mediaTypes.js";
 
@@ -19,6 +21,16 @@ export default async function constructResponse(request, resource) {
   // Determine media type, what data we'll send, and encoding.
   const url = new URL(request?.url ?? "", `https://${request?.headers.host}`);
 
+  if (!isPacked(resource) && typeof resource.pack === "function") {
+    resource = await resource.pack();
+    if (typeof resource === "function") {
+      resource = await resource();
+    }
+    if (resource instanceof Response) {
+      return resource;
+    }
+  }
+
   if (!url.pathname.endsWith("/") && Tree.isMaplike(resource)) {
     // Maplike resource: redirect to its index page.
     const Location = `${url.pathname}/`;
@@ -30,16 +42,6 @@ export default async function constructResponse(request, resource) {
     });
   }
 
-  if (!isPacked(resource) && typeof resource.pack === "function") {
-    resource = await resource.pack();
-    if (typeof resource === "function") {
-      resource = await resource();
-    }
-    if (resource instanceof Response) {
-      return resource;
-    }
-  }
-
   let body = resource;
   if (!isPacked(resource)) {
     // Can we treat it as text?
@@ -50,6 +52,7 @@ export default async function constructResponse(request, resource) {
   }
 
   // Determine MIME type
+  /** @type {string | undefined} */
   let mediaType;
   if (resource.mediaType) {
     // Resource indicates its own media type.
@@ -77,6 +80,10 @@ export default async function constructResponse(request, resource) {
         } else {
           mediaType = sniffedType.toString();
         }
+        if (mediaType === "text/plain") {
+          // Prefer UTF-8 encoding for text/plain
+          mediaType += "; charset=utf-8";
+        }
       }
     }
   }
@@ -91,7 +98,35 @@ export default async function constructResponse(request, resource) {
     );
   }
 
-  const options = mediaType ? { headers: { "Content-Type": mediaType } } : {};
-  const response = new Response(body, options);
+  // Compute ETag from the body content.
+  let etag;
+  if (!resource[symbols.volatileSymbol]) {
+    const hash = createHash("sha1");
+    if (typeof body === "string" || body instanceof String) {
+      hash.update(String(body), "utf8");
+    } else {
+      hash.update(body);
+    }
+    const digest = hash.digest("hex");
+    // Store ETag with quotes in cache to match If-None-Match header
+    etag = `"${digest}"`;
+  }
+
+  /** @type {Record<string, string>} */
+  const headers = {};
+  if (mediaType) {
+    headers["Content-Type"] = mediaType;
+  }
+  if (etag) {
+    headers["Cache-Control"] = "no-cache";
+    headers.ETag = etag;
+  }
+
+  const response = new Response(body, { headers });
+
+  if (resource[symbols.volatileSymbol]) {
+    response[symbols.volatileSymbol] = true;
+  }
+
   return response;
 }

package/src/server/server.js

@@ -1,10 +1,10 @@
 import {
-  TraverseError,
-  Tree,
   keysFromPath,
   trailingSlash,
+  TraverseError,
+  Tree,
 } from "@weborigami/async-tree";
-import { formatError } from "@weborigami/language";
+import { formatError, systemCache, SystemCacheMap } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
 import parsePostData from "./parsePostData.js";
@@ -13,35 +13,30 @@ import parsePostData from "./parsePostData.js";
  * Copy a constructed response to a ServerResponse. Return true if the response
  * was successfully copied, and false if there was a problem.
  *
- * @param {Response} constructed
+ * @param {Response} original
  * @param {ServerResponse} response
  */
-async function copyResponse(constructed, response) {
-  response.statusCode = constructed.status;
-  response.statusMessage = constructed.statusText;
+async function copyResponse(original, response) {
+  const clone = original.clone();
+  response.statusCode = clone.status;
+  response.statusMessage = clone.statusText;
 
   // @ts-ignore Headers has an iterator in ES2022 but tsc doesn't know that.
-  for (const [key, value] of constructed.headers) {
+  for (const [key, value] of clone.headers) {
     response.setHeader(key, value);
   }
 
-  if (constructed.body) {
-    try {
-      // Write the response body to the ServerResponse.
-      const reader = constructed.body.getReader();
-      let { done, value } = await reader.read();
-      while (!done) {
-        response.write(value);
-        ({ done, value } = await reader.read());
-      }
-      response.end();
-    } catch (/** @type {any} */ error) {
-      console.error(error.message);
-      return false;
+  if (clone.body) {
+    // Write the response body
+    const reader = clone.body.getReader();
+    let { done, value } = await reader.read();
+    while (!done) {
+      response.write(value);
+      ({ done, value } = await reader.read());
     }
   }
 
-  return true;
+  response.end();
 }
 
 /**
@@ -54,36 +49,68 @@ async function copyResponse(constructed, response) {
 export async function handleRequest(request, response, map) {
   // For parsing purposes, we assume HTTPS -- it doesn't affect parsing.
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
-  const keys = keysFromUrl(url);
 
+  // Do we already have an ETag for this resource?
+  let cachePath = SystemCacheMap.joinPath("_site", url.pathname.slice(1));
+  if (url.pathname.endsWith("/")) {
+    cachePath += "index.html";
+  }
+  const cacheEntry = systemCache.get(cachePath)?.value;
+  const etag = cacheEntry?.headers?.get("Etag");
+  if (etag) {
+    // Does the client already have this version?
+    const ifNoneMatch = request?.headers?.["if-none-match"];
+    if (ifNoneMatch === etag) {
+      // Client already has this version
+      response.writeHead(304, {
+        "Cache-Control": "no-cache",
+        ETag: etag,
+      });
+      response.end();
+      return true;
+    }
+  }
+
+  const keys = keysFromUrl(url);
   const data = request.method === "POST" ? await parsePostData(request) : null;
 
   // Ask the tree for the resource with those keys.
-  let resource;
   try {
-    resource = await Tree.traverseOrThrow(map, ...keys);
-
-    // If resource is a function, invoke to get the object we want to return.
-    // For a POST request, pass the data to the function.
-    if (typeof resource === "function") {
-      resource = data ? await resource(data) : await resource();
+    // We wrap the tree traversal in a call that will both set the etag for this
+    // resource and copy the constructed response to the ServerResponse. The
+    // etag is already included in the response headers so we don't need to
+    // receive it here.
+    const constructed = await systemCache.getOrInsertComputedAsync(
+      cachePath,
+      async () => {
+        let resource = await Tree.traverseOrThrow(map, ...keys);
+
+        // If resource is a function, invoke to get the object we want to return.
+        // For a POST request, pass the data to the function.
+        if (typeof resource === "function") {
+          resource = data ? await resource(data) : await resource();
+        }
+
+        // Construct the response
+        return resource != null
+          ? await constructResponse(request, resource)
+          : null;
+      },
+    );
+
+    // Copy the constructed (and cached) response to the server response
+    if (constructed) {
+      await copyResponse(constructed, response);
+      return true;
     }
-
-    if (resource == null) {
-      return false;
-    }
-
-    // Construct the response.
-    const constructed = await constructResponse(request, resource);
-
-    // Copy the construct response to the ServerResponse and return true if
-    // the response was valid.
-    return copyResponse(constructed, response);
   } catch (/** @type {any} */ error) {
     // Display an error
-    respondWithError(response, error);
+    await respondWithError(response, error);
     return true;
   }
+
+  // No resource found at this path.
+  return false;
 }
 
 export function keysFromUrl(url) {

package/src/origami/project.js

@@ -1,6 +0,0 @@
-import { projectRoot } from "@weborigami/language";
-
-export default async function project() {
-  console.warn("Origami.project has been renamed to Origami.projectRoot");
-  return projectRoot();
-}