@weborigami/origami 0.0.40 → 0.0.42

package/src/server/constructResponse.js

@@ -0,0 +1,126 @@
+import {
+  SiteTree,
+  Tree,
+  isPlainObject,
+  isStringLike,
+} from "@weborigami/async-tree";
+import { extname } from "@weborigami/language";
+import * as serialize from "../common/serialize.js";
+import { toString } from "../common/utilities.js";
+import { mediaTypeForExtension } from "./mediaTypes.js";
+
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+
+/**
+ * Given a resource that was returned from a route, construct an appropriate
+ * HTTP Response indicating what should be sent to the client. Return null
+ * if the resource is not a valid response.
+ *
+ * @param {import("node:http").IncomingMessage} request
+ * @param {any} resource
+ * @returns {Promise<Response|null>}
+ */
+export default async function constructResponse(request, resource) {
+  if (resource instanceof Response) {
+    // Already a Response, return as is.
+    return resource;
+  } else if (!resource) {
+    return null;
+  }
+
+  // Determine media type, what data we'll send, and encoding.
+  const url = new URL(request.url ?? "", `https://${request.headers.host}`);
+  const extension = extname(url.pathname).toLowerCase();
+  let mediaType = extension ? mediaTypeForExtension[extension] : undefined;
+
+  if (
+    mediaType === undefined &&
+    !url.pathname.endsWith("/") &&
+    (Tree.isAsyncTree(resource) ||
+      isPlainObject(resource) ||
+      resource instanceof Array)
+  ) {
+    // Redirect to an index page for the result.
+    const Location = `${request.url}/`;
+    return new Response("ok", {
+      headers: {
+        Location,
+      },
+      status: 307,
+    });
+  }
+
+  // If the request is for a JSON or YAML result, and the resource we got
+  // isn't yet a string or Buffer, convert the resource to JSON or YAML now.
+  if (
+    (mediaType === "application/json" || mediaType === "text/yaml") &&
+    !isStringLike(resource)
+  ) {
+    const tree = Tree.from(resource);
+    resource =
+      mediaType === "text/yaml"
+        ? await serialize.toYaml(tree)
+        : await serialize.toJson(tree);
+  } else if (
+    mediaType === undefined &&
+    (isPlainObject(resource) || resource instanceof Array)
+  ) {
+    // The resource is data, try showing it as YAML.
+    const tree = Tree.from(resource);
+    resource = await serialize.toYaml(tree);
+    mediaType = "text/yaml";
+  }
+
+  let body;
+  if (mediaType) {
+    body = SiteTree.mediaTypeIsText(mediaType) ? toString(resource) : resource;
+  } else {
+    body = textOrObject(resource);
+    // Infer media type.
+    mediaType =
+      typeof body !== "string"
+        ? "application/octet-stream"
+        : body.trimStart().startsWith("<")
+        ? "text/html"
+        : "text/plain";
+  }
+
+  // Assume text is encoded in UTF-8.
+  if (SiteTree.mediaTypeIsText(mediaType)) {
+    mediaType += "; charset=utf-8";
+  }
+
+  // If we didn't get back some kind of data that response.write() accepts,
+  // assume it was an error.
+  const validResponse = typeof body === "string" || body instanceof TypedArray;
+  if (!validResponse) {
+    const typeName = body?.constructor?.name ?? typeof body;
+    console.error(
+      `A served tree must return a string or a TypedArray (such as a Buffer) but returned an instance of ${typeName}.`
+    );
+    return null;
+  }
+
+  return new Response(body, {
+    headers: {
+      "Content-Type": mediaType,
+    },
+  });
+}
+
+/**
+ * Convert to a string if we can, but leave objects that convert to something
+ * like "[object Object]" alone.
+ *
+ * @param {any} object
+ */
+function textOrObject(object) {
+  if (object instanceof ArrayBuffer) {
+    // Convert to Buffer.
+    return Buffer.from(object);
+  } else if (object instanceof TypedArray) {
+    // Return typed arrays as is.
+    return object;
+  }
+  return toString(object);
+}

package/src/server/mediaTypes.js

@@ -79,19 +79,3 @@ export const mediaTypeForExtension = {
   ".yaml": "text/yaml", // Not official
   ".zip": "application/zip",
 };
-
-export const mediaTypeIsText = {
-  "application/json": true,
-  "application/ld+json": true,
-  "application/vnd.oasis.opendocument.text": true,
-  "application/x-httpd-php": true,
-  "application/x-sh": true,
-  "application/xhtml+xml": true,
-  "text/css": true,
-  "text/csv": true,
-  "text/html": true,
-  "text/javascript": true,
-  "text/plain": true,
-  "text/yaml": true,
-  "text/yml": true,
-};

package/src/server/server.js

@@ -1,16 +1,41 @@
-import {
-  ObjectTree,
-  Tree,
-  isPlainObject,
-  isStringLike,
-  keysFromPath,
-} from "@weborigami/async-tree";
-import { Scope, extname } from "@weborigami/language";
-import * as serialize from "../common/serialize.js";
-import { toString } from "../common/utilities.js";
-import { mediaTypeForExtension, mediaTypeIsText } from "./mediaTypes.js";
+import { ObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
+import { Scope, formatError } from "@weborigami/language";
+import { ServerResponse } from "node:http";
+import constructResponse from "./constructResponse.js";
 
-const TypedArray = Object.getPrototypeOf(Uint8Array);
+/**
+ * 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 {ServerResponse} response
+ */
+async function copyResponse(constructed, response) {
+  response.statusCode = constructed.status;
+  response.statusMessage = constructed.statusText;
+
+  for (const [key, value] of constructed.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;
+    }
+  }
+
+  return true;
+}
 
 // Extend the tree's scope with the URL's search parameters.
 function extendTreeScopeWithParams(tree, url) {
@@ -38,21 +63,16 @@ function extendTreeScopeWithParams(tree, url) {
   return extendedTree;
 }
 
-// Asynchronous tree router as Express middleware.
-export function treeRouter(tree) {
-  // Return a router for the tree source.
-  return async function (request, response, next) {
-    const handled = await handleRequest(request, response, tree);
-    if (!handled) {
-      // Module not found, let next middleware function try.
-      next();
-    }
-  };
-}
-
+/**
+ * Handle a client request.
+ *
+ * @param {import("node:http").IncomingMessage} request
+ * @param {ServerResponse} response
+ * @param {import("@weborigami/types").AsyncTree} tree
+ */
 export async function handleRequest(request, response, tree) {
   // For parsing purposes, we assume HTTPS -- it doesn't affect parsing.
-  const url = new URL(request.url, `https://${request.headers.host}`);
+  const url = new URL(request.url ?? "", `https://${request.headers.host}`);
   const keys = keysFromUrl(url);
 
   const extendedTree =
@@ -73,93 +93,15 @@ export async function handleRequest(request, response, tree) {
     return true;
   }
 
-  let mediaType;
-
-  if (!resource) {
-    return false;
-  }
-
-  // Determine media type, what data we'll send, and encoding.
-  const extension = extname(url.pathname).toLowerCase();
-  mediaType = extension ? mediaTypeForExtension[extension] : undefined;
-
-  if (
-    mediaType === undefined &&
-    !request.url.endsWith("/") &&
-    (Tree.isAsyncTree(resource) ||
-      isPlainObject(resource) ||
-      resource instanceof Array)
-  ) {
-    // Redirect to an index page for the result.
-    // Redirect to the root of the tree.
-    const Location = `${request.url}/`;
-    response.writeHead(307, { Location });
-    response.end("ok");
-    return true;
-  }
-
-  // If the request is for a JSON or YAML result, and the resource we got
-  // isn't yet a string or Buffer, convert the resource to JSON or YAML now.
-  if (
-    (mediaType === "application/json" || mediaType === "text/yaml") &&
-    !isStringLike(resource)
-  ) {
-    const tree = Tree.from(resource);
-    resource =
-      mediaType === "text/yaml"
-        ? await serialize.toYaml(tree)
-        : await serialize.toJson(tree);
-  } else if (
-    mediaType === undefined &&
-    (isPlainObject(resource) || resource instanceof Array)
-  ) {
-    // The resource is data, try showing it as YAML.
-    const tree = Tree.from(resource);
-    resource = await serialize.toYaml(tree);
-    mediaType = "text/yaml";
-  }
-
-  let data;
-  if (mediaType) {
-    data = mediaTypeIsText[mediaType] ? toString(resource) : resource;
-  } else {
-    data = textOrObject(resource);
-  }
-
-  if (!mediaType) {
-    // Can't identify media type; infer default type.
-    mediaType =
-      typeof data !== "string"
-        ? "application/octet-stream"
-        : data.trimStart().startsWith("<")
-        ? "text/html"
-        : "text/plain";
-  }
-  const encoding = mediaTypeIsText[mediaType] ? "utf-8" : undefined;
-
-  // If we didn't get back some kind of data that response.write() accepts,
-  // assume it was an error.
-  const validResponse = typeof data === "string" || data instanceof TypedArray;
-
-  if (!validResponse) {
-    const typeName = data?.constructor?.name ?? typeof data;
-    console.error(
-      `A served tree must return a string or a TypedArray (such as a Buffer) but returned an instance of ${typeName}.`
-    );
-    return false;
-  }
-
-  response.writeHead(200, {
-    "Content-Type": mediaType,
-  });
-  try {
-    response.end(data, encoding);
-  } catch (/** @type {any} */ error) {
-    console.error(error.message);
+  // Construct the response.
+  const constructed = await constructResponse(request, resource);
+  if (!constructed) {
     return false;
   }
 
-  return true;
+  // Copy the construct response to the ServerResponse and return true if
+  // the response was valid.
+  return copyResponse(constructed, response);
 }
 
 function keysFromUrl(url) {
@@ -211,16 +153,7 @@ export function requestListener(treelike) {
  * the console.
  */
 function respondWithError(response, error) {
-  let message = "";
-  // Work up to the root cause, displaying intermediate messages as we go up.
-  while (error.cause) {
-    message += error.message + `\n`;
-    error = error.cause;
-  }
-  if (error.name) {
-    message += `${error.name}: `;
-  }
-  message += error.message;
+  let message = formatError(error);
   // Prevent HTML in the error message from being interpreted as HTML.
   message = message.replace(/</g, "&lt;").replace(/>/g, "&gt;");
   const html = `<!DOCTYPE html>
@@ -241,16 +174,14 @@ ${message}
   console.error(message);
 }
 
-/**
- * Convert to a string if we can, but leave objects that convert to something
- * like "[object Object]" alone.
- *
- * @param {any} object
- */
-function textOrObject(object) {
-  // Return buffers and typed arrays as is.
-  if (object instanceof ArrayBuffer || object instanceof TypedArray) {
-    return object;
-  }
-  return toString(object);
+// Asynchronous tree router as Express middleware.
+export function treeRouter(tree) {
+  // Return a router for the tree source.
+  return async function (request, response, next) {
+    const handled = await handleRequest(request, response, tree);
+    if (!handled) {
+      // Module not found, let next middleware function try.
+      next();
+    }
+  };
 }

package/src/builtins/@tree/flowSvg.js

@@ -1,55 +0,0 @@
-import graphviz from "graphviz-wasm";
-
-let graphvizLoaded = false;
-
-export default async function flowSvg(flow) {
-  if (!graphvizLoaded) {
-    await graphviz.loadWASM();
-    graphvizLoaded = true;
-  }
-  const dot = flowDot(flow);
-  const svg = await graphviz.layout(dot, "svg");
-  return svg;
-}
-
-function flowDot(flow) {
-  const nodes = [];
-  const edges = [];
-  for (const [key, record] of Object.entries(flow)) {
-    const dependencies = record.dependencies ?? [];
-    let label = record.label ?? key;
-    if (record.undefined) {
-      label += " (?)";
-    }
-    const virtualNode = dependencies.length > 0;
-    const url = record.url ?? key;
-    const nodeLabel = `label="${label}"`;
-    const nodeUrl = `URL=".scope/${url}"`;
-    const nodeShape = record.undefined ? `shape="none"` : "";
-    const nodeStyle = virtualNode ? `style="dashed"` : null;
-    const attributes = [nodeLabel, nodeShape, nodeStyle, nodeUrl].filter(
-      (attribute) => attribute
-    );
-    const nodeDot = `  "${key}" [${attributes.join("; ")}];`;
-    nodes.push(nodeDot);
-
-    for (const dependency of dependencies) {
-      edges.push(`  "${dependency}" -> "${key}";`);
-    }
-  }
-
-  return `digraph dataflow {
-  nodesep=1;
-  rankdir=LR;
-  ranksep=1.5;
-  node [color="gray70"; fillcolor="white"; fontname="Helvetica"; fontsize="10"; nojustify="true"; style="filled"; shape="box"];
-  edge [arrowhead="onormal"; arrowsize="0.75"; color="gray60"; fontname="Helvetica"; fontsize="10"; labeldistance="5"];
-
-${nodes.join("\n")}
-
-${edges.join("\n")}
-}`;
-}
-
-// flowSvg.usage = `flowSvg <dataflow>\tRenders the output of dataflow() as an SVG`;
-// flowSvg.documentation = "https://weborigami.org/cli/builtins.html#flowSvg";

package/src/builtins/@tree/from.js

@@ -1,27 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-
-/**
- * Cast the indicated treelike to a tree.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function tree(treelike) {
-  assertScopeIsDefined(this);
-  treelike = treelike ?? (await this?.get("@current"));
-  if (treelike === undefined) {
-    return undefined;
-  }
-
-  /** @type {AsyncTree} */
-  let result = Tree.from(treelike);
-  result = Scope.treeWithScope(result, this);
-  return result;
-}
-
-tree.usage = `from <treelike>\tConvert JSON, YAML, function, or plain object to a tree`;
-tree.documentation = "https://weborigami.org/cli/builtins.html#tree";

package/src/builtins/@tree/fromJson.js

@@ -1,6 +0,0 @@
-export default async function fromJson(text) {
-  return text ? JSON.parse(text) : undefined;
-}
-
-fromJson.usage = `fromJson <text>\tParse text as JSON`;
-fromJson.documentation = "https://weborigami.org/cli/builtins.html#fromJson";

package/src/builtins/@tree/fromYaml.js

@@ -1,24 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-import * as serialize from "../../common/serialize.js";
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-
-/**
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/async-tree").StringLike} StringLike
- *
- * @param {StringLike} text
- * @this {AsyncTree|null}
- */
-export default async function fromYaml(text) {
-  assertScopeIsDefined(this);
-  let result = text ? serialize.parseYaml(String(text)) : undefined;
-  if (this && Tree.isAsyncTree(result)) {
-    result = Scope.treeWithScope(result, this);
-  }
-  return result;
-}
-
-fromYaml.usage = `fromYaml <text>\tParse text as YAML`;
-fromYaml.documentation = "https://weborigami.org/cli/builtins.html#fromYaml";

package/src/builtins/@tree/nextKey.js

@@ -1,29 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-
-/**
- * Returns the key after the indicated key.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} treelike
- * @param {any} key
- */
-export default async function nextKey(treelike, key) {
-  assertScopeIsDefined(this);
-  const tree = Tree.from(treelike);
-  let returnNextKey = false;
-  for (const treeKey of await tree.keys()) {
-    if (returnNextKey) {
-      return treeKey;
-    }
-    if (treeKey === key) {
-      returnNextKey = true;
-    }
-  }
-  return undefined;
-}
-
-nextKey.usage = `nextKey <tree>, <key>\tReturns the key after the indicated key`;
-nextKey.documentation = "https://weborigami.org/cli/builtins.html#nextKey";

package/src/builtins/@tree/previousKey.js

@@ -1,29 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-
-/**
- * Returns the key before the indicated key.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- *
- * @param {Treelike} treelike
- * @param {any} key
- * @this {AsyncTree|null}
- */
-export default async function previousKey(treelike, key) {
-  assertScopeIsDefined(this);
-  const tree = Tree.from(treelike);
-  let previousKey = undefined;
-  for (const treeKey of await tree.keys()) {
-    if (treeKey === key) {
-      return previousKey;
-    }
-    previousKey = treeKey;
-  }
-  return undefined;
-}
-
-previousKey.usage = `previousKey <tree>, <key>\tReturns the key before the indicated key`;
-previousKey.documentation =
-  "https://weborigami.org/cli/builtins.html#previousKey";