@weborigami/origami 0.6.17 → 0.7.0-beta.2

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/dev/changes2.js

@@ -1,38 +0,0 @@
-import { args, isStringlike, toString, Tree } from "@weborigami/async-tree";
-
-/**
- * Given an old tree and a new tree, return a tree of changes indicated
- * by the values: "added", "changed", or "deleted".
- *
- * @typedef {import("@weborigami/async-tree").Maplike} Maplike
- *
- * @param {Maplike} oldMaplike
- * @param {Maplike} newMaplike
- */
-export default async function changes(oldMaplike, newMaplike) {
-  const oldTree = await args.map(oldMaplike, "Dev.changes", {
-    deep: true,
-    position: 1,
-  });
-  const newTree = await args.map(newMaplike, "Dev.changes", {
-    deep: true,
-    position: 2,
-  });
-
-  const combination = await Tree.combine(oldTree, newTree, compare);
-  return combination;
-}
-
-function compare(oldValue, newValue) {
-  if (oldValue !== undefined && newValue === undefined) {
-    return "deleted";
-  } else if (oldValue === undefined && newValue !== undefined) {
-    return "added";
-  } else if (isStringlike(oldValue) && isStringlike(newValue)) {
-    const oldText = toString(oldValue);
-    const newText = toString(newValue);
-    return oldText === newText ? undefined : "changed";
-  } else {
-    return oldValue === newValue ? undefined : "changed";
-  }
-}

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();
-}