@weborigami/origami 0.0.66-beta.1 → 0.0.66-beta.2

package/exports/PathTransform.js

@@ -1,3 +1,5 @@
+import { trailingSlash } from "@weborigami/async-tree";
+
 export default function PathTransform(Base) {
   return class Path extends Base {
     async get(key) {
@@ -6,7 +8,7 @@ export default function PathTransform(Base) {
         // @ts-ignore
         const path = this[PathTransform.pathKey]
           ? // @ts-ignore
-            `${this[PathTransform.pathKey]}/${key}`
+            `${trailingSlash.add(this[PathTransform.pathKey])}${key}`
           : key;
         value[PathTransform.pathKey] = path;
       }

package/exports/exports.js

@@ -72,6 +72,7 @@ export { default as paginateFn } from "../src/builtins/@paginateFn.js";
 export { default as parent } from "../src/builtins/@parent.js";
 export { default as perf } from "../src/builtins/@perf.js";
 export { default as plain } from "../src/builtins/@plain.js";
+export { default as post } from "../src/builtins/@post.js";
 export { default as project } from "../src/builtins/@project.js";
 export { default as redirect } from "../src/builtins/@redirect.js";
 export { default as regexMatch } from "../src/builtins/@regexMatch.js";
@@ -84,6 +85,7 @@ export { default as setDeep } from "../src/builtins/@setDeep.js";
 export { default as shell } from "../src/builtins/@shell.js";
 export { default as shuffle } from "../src/builtins/@shuffle.js";
 export { default as sitemap } from "../src/builtins/@sitemap.js";
+export * from "../src/builtins/@slash.js";
 export { default as slug } from "../src/builtins/@slug.js";
 export { default as sort } from "../src/builtins/@sort.js";
 export { default as sortFn } from "../src/builtins/@sortFn.js";
@@ -139,4 +141,5 @@ export { default as origamiHighlightDefinition } from "../src/misc/origamiHighli
 export { default as treeDot } from "../src/misc/treeDot.js";
 export { default as constructResponse } from "../src/server/constructResponse.js";
 export * from "../src/server/mediaTypes.js";
+export { default as parsePostData } from "../src/server/parsePostData.js";
 export * from "../src/server/server.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.66-beta.1",
+  "version": "0.0.66-beta.2",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -13,17 +13,17 @@
   "main": "./exports/exports.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.5.4",
-    "typescript": "5.5.4"
+    "@types/node": "22.7.4",
+    "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.66-beta.1",
-    "@weborigami/language": "0.0.66-beta.1",
-    "@weborigami/types": "0.0.66-beta.1",
+    "@weborigami/async-tree": "0.0.66-beta.2",
+    "@weborigami/language": "0.0.66-beta.2",
+    "@weborigami/types": "0.0.66-beta.2",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.10.0",
-    "marked": "14.1.1",
+    "marked": "14.1.2",
     "marked-gfm-heading-id": "4.1.0",
     "marked-highlight": "2.1.4",
     "marked-smartypants": "1.1.8",

package/src/builtins/@crawl.js

@@ -4,6 +4,7 @@ import {
   deepMerge,
   isPlainObject,
   keysFromPath,
+  trailingSlash,
 } from "@weborigami/async-tree";
 import { InvokeFunctionsTransform, extname } from "@weborigami/language";
 import * as utilities from "../common/utilities.js";
@@ -75,7 +76,7 @@ export default async function crawl(treelike, baseHref) {
     for (const resourcePath of resourcePaths) {
       const resourceKeys = adjustKeys(keysFromPath(resourcePath));
       const fn = () => {
-        return traverse(tree, ...resourceKeys);
+        return Tree.traverse(tree, ...resourceKeys);
       };
       addValueToObject(resources, resourceKeys, fn);
     }
@@ -100,18 +101,19 @@ export default async function crawl(treelike, baseHref) {
 }
 
 // For indexing and storage purposes, treat a path that ends in a trailing slash
-// (or the dot we use to seed the queue) as if it ends in index.html.
+// as if it ends in index.html.
 function adjustKeys(keys) {
-  const adjustedKeys = keys.slice();
-  if (adjustedKeys.at(-1) === "") {
-    adjustedKeys[adjustedKeys.length - 1] = "index.html";
+  if (keys.length > 0 && !trailingSlash.has(keys.at(-1))) {
+    return keys;
   }
+  const adjustedKeys = keys.slice();
+  adjustedKeys.push("index.html");
   return adjustedKeys;
 }
 
 function addValueToObject(object, keys, value) {
   for (let i = 0, current = object; i < keys.length; i++) {
-    const key = keys[i];
+    const key = trailingSlash.remove(keys[i]);
     if (i === keys.length - 1) {
       // Write out value
       if (isPlainObject(current[key])) {
@@ -150,7 +152,7 @@ async function* crawlPaths(tree, baseUrl) {
   const promisesForPaths = {};
 
   // Seed the promise dictionary with robots.txt and the root path.
-  const initialPaths = ["/robots.txt", ""];
+  const initialPaths = ["/robots.txt", "/"];
   initialPaths.forEach((path) => {
     promisesForPaths[path] = processPath(tree, path, baseUrl);
   });
@@ -468,14 +470,13 @@ async function processPath(tree, path, baseUrl) {
   }
 
   // Convert path to keys
-  /** @type {any[]} */
-  let keys = path === "" ? [""] : keysFromPath(path);
+  const keys = keysFromPath(path);
 
   // Traverse tree to get value.
-  let value = await traverse(tree, ...keys);
+  let value = await Tree.traverse(tree, ...keys);
   if (Tree.isAsyncTree(value)) {
     // Path is actually a directory; see if it has an index.html
-    value = await traverse(value, "index.html");
+    value = await Tree.traverse(value, "index.html");
   }
 
   const adjustedKeys = adjustKeys(keys);
@@ -508,18 +509,5 @@ async function processPath(tree, path, baseUrl) {
   };
 }
 
-async function traverse(tree, ...keys) {
-  if (tree.resolve && keys.length > 1) {
-    // Tree like SiteTree that supports resolve() method
-    const lastKey = keys.pop();
-    const path = keys.join("/");
-    const resolved = tree.resolve(path);
-    return resolved.get(lastKey);
-  } else {
-    // Regular async tree
-    return Tree.traverse(tree, ...keys);
-  }
-}
-
 crawl.usage = `@crawl <tree>\tCrawl a tree`;
 crawl.documentation = "https://weborigami.org/language/@crawl.html";

package/src/builtins/@debug.js

@@ -39,8 +39,10 @@ function DebugTransform(Base) {
       const parent = this;
 
       // Since this transform is for diagnostic purposes, cast any treelike
-      // result to a tree so we can debug the result too.
-      if (Tree.isTreelike(value)) {
+      // result to a tree so we can debug the result too. (Don't do this for
+      // functions, as that can be undesirable, e.g., when writing functions
+      // that handle POST requests.)
+      if (Tree.isTreelike(value) && typeof value !== "function") {
         value = Tree.from(value, { parent });
         if (!isTransformApplied(DebugTransform, value)) {
           value = transformObject(DebugTransform, value);

package/src/builtins/@inners.js

@@ -1,8 +1,9 @@
-import { Tree } from "@weborigami/async-tree";
+import { trailingSlash, Tree } from "@weborigami/async-tree";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
- * Return the source nodes of the tree: the nodes with children.
+ * Return the interior nodes of the tree. This relies on subtree keys having
+ * trailing slashes.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
@@ -19,12 +20,8 @@ export default async function inners(treelike) {
     },
 
     async keys() {
-      const subtreeKeys = [];
-      for (const key of await tree.keys()) {
-        if (await Tree.isKeyForSubtree(tree, key)) {
-          subtreeKeys.push(key);
-        }
-      }
+      const keys = [...(await tree.keys())];
+      const subtreeKeys = keys.filter(trailingSlash.has);
       return subtreeKeys;
     },
   };
@@ -32,5 +29,5 @@ export default async function inners(treelike) {
   return result;
 }
 
-inners.usage = `@inners <tree>\tThe source nodes of the tree`;
+inners.usage = `@inners <tree>\tThe interior nodes of the tree`;
 inners.documentation = "https://weborigami.org/cli/builtins.html#inners";

package/src/builtins/@mapFn.js

@@ -91,7 +91,7 @@ export default function mapFnBuiltin(operation) {
       );
       return resultKey;
     }
-    const keyFns = cachedKeyFunctions(scopedKeyFn);
+    const keyFns = cachedKeyFunctions(scopedKeyFn, deep);
     extendedKeyFn = keyFns.key;
     extendedInverseKeyFn = keyFns.inverseKey;
   } else {

package/src/builtins/@post.js

@@ -0,0 +1,45 @@
+import {
+  isStringLike,
+  isUnpackable,
+  toPlainValue,
+  toString,
+  Tree,
+} from "@weborigami/async-tree";
+
+/**
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {string} url
+ * @param {any} data
+ */
+export default async function post(url, data) {
+  let body;
+  let headers;
+  if (isUnpackable(data)) {
+    data = await data.unpack();
+  }
+  if (Tree.isTreelike(data)) {
+    const value = await toPlainValue(data);
+    body = JSON.stringify(value);
+    headers = {
+      "Content-Type": "application/json",
+    };
+  } else if (isStringLike(data)) {
+    body = toString(data);
+    headers = {
+      "Content-Type": "text/plain",
+    };
+  } else {
+    body = data;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    body,
+    headers,
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to POST to ${url}. Error ${response.status}: ${response.statusText}`
+    );
+  }
+  return response.arrayBuffer();
+}

package/src/builtins/@serve.js

@@ -26,9 +26,6 @@ export default async function serve(treelike, port) {
   let tree;
   if (treelike) {
     tree = Tree.from(treelike, { parent: this });
-
-    // TODO: Instead of applying ExplorableSiteTransform, apply a transform
-    // that just maps the empty string to index.html.
     if (!isTransformApplied(ExplorableSiteTransform, tree)) {
       tree = transformObject(ExplorableSiteTransform, tree);
     }

package/src/builtins/@slash.js

@@ -0,0 +1 @@
+export { trailingSlash as default } from "@weborigami/async-tree";

package/src/builtins/@watch.js

@@ -1,4 +1,5 @@
 import { Tree } from "@weborigami/async-tree";
+import { formatError } from "@weborigami/language";
 import ConstantTree from "../common/ConstantTree.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
@@ -48,8 +49,8 @@ async function evaluateTree(parent, fn) {
   let result;
   try {
     result = await fn.call(parent);
-  } catch (error) {
-    message = messageForError(error);
+  } catch (/** @type {any} */ error) {
+    message = formatError(error);
   }
   tree = result ? Tree.from(result, { parent }) : undefined;
   if (tree) {
@@ -64,29 +65,19 @@ async function evaluateTree(parent, fn) {
   return tree;
 }
 
-function messageForError(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;
-  return message;
-}
-
 // Update an indirect pointer to a target.
 function updateIndirectPointer(indirect, target) {
   // Clean the pointer of any named properties or symbols that have been set
   // directly on it.
-  for (const key of Object.getOwnPropertyNames(indirect)) {
-    delete indirect[key];
-  }
-  for (const key of Object.getOwnPropertySymbols(indirect)) {
-    delete indirect[key];
+  try {
+    for (const key of Object.getOwnPropertyNames(indirect)) {
+      delete indirect[key];
+    }
+    for (const key of Object.getOwnPropertySymbols(indirect)) {
+      delete indirect[key];
+    }
+  } catch {
+    // Ignore errors.
   }
 
   Object.setPrototypeOf(indirect, target);

package/src/common/CommandModulesTransform.js

@@ -1,3 +1,4 @@
+import { trailingSlash } from "@weborigami/async-tree";
 import path from "node:path";
 
 /**
@@ -18,6 +19,7 @@ export default function CommandsModulesTransform(Base) {
       }
 
       // See if we have a JS module for the requested key.
+      key = trailingSlash.remove(key);
       if (key === undefined || key.endsWith?.(".js")) {
         return undefined;
       }

package/src/common/ExplorableSiteTransform.js

@@ -25,11 +25,6 @@ import { isTransformApplied, transformObject } from "../common/utilities.js";
 export default function ExplorableSiteTransform(Base) {
   return class ExplorableSite extends Base {
     async get(key) {
-      // The empty string key represents "index.html".
-      if (key === "") {
-        key = "index.html";
-      }
-
       // Ask the tree if it has the key.
       let value = await super.get(key);
 
@@ -49,11 +44,6 @@ export default function ExplorableSiteTransform(Base) {
         if (!isTransformApplied(ExplorableSiteTransform, value)) {
           value = transformObject(ExplorableSiteTransform, value);
         }
-
-        if (key.endsWith?.("/")) {
-          // Instead of return the tree directly, return an index for it.
-          value = await index.call(this, value);
-        }
       } else if (value?.unpack) {
         // If the value isn't a tree, but has a tree attached via an `unpack`
         // method, wrap the unpack method to add this transform.
@@ -61,7 +51,8 @@ export default function ExplorableSiteTransform(Base) {
         const parent = this;
         value.unpack = async () => {
           const content = await original();
-          if (!Tree.isTraversable(content)) {
+          // See function notes at @debug
+          if (!Tree.isTraversable(content) || typeof content === "function") {
             return content;
           }
           /** @type {any} */
@@ -77,5 +68,11 @@ export default function ExplorableSiteTransform(Base) {
       }
       return value;
     }
+
+    // If this value is given to the server, the server will call this pack()
+    // method. We respond with the index page.
+    async pack() {
+      return this.get("index.html");
+    }
   };
 }

package/src/common/FilterTree.js

@@ -1,4 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
+import { trailingSlash, Tree } from "@weborigami/async-tree";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -40,7 +40,7 @@ export default class FilterTree {
       // must be a tree too.
       const match =
         (!isFilterValueTree && filterValue) ||
-        (isFilterValueTree && (await Tree.isKeyForSubtree(this.tree, key)));
+        (isFilterValueTree && trailingSlash.has(key));
       if (match) {
         keys.add(key);
       }

package/src/common/GlobTree.js

@@ -1,10 +1,4 @@
-import {
-  DeepObjectTree,
-  ObjectTree,
-  Tree,
-  isPlainObject,
-  merge,
-} from "@weborigami/async-tree";
+import { ObjectTree, Tree, merge, trailingSlash } from "@weborigami/async-tree";
 
 const globstar = "**";
 
@@ -14,15 +8,17 @@ const globstar = "**";
  */
 export default class GlobTree {
   constructor(globs) {
-    this.globs = isPlainObject(globs)
-      ? new DeepObjectTree(globs)
-      : Tree.from(globs);
+    this.globs = Tree.from(globs, { deep: true });
   }
 
   async get(key) {
     if (typeof key !== "string") {
       return undefined;
     }
+
+    // Remove trailing slash if it exists
+    key = trailingSlash.remove(key);
+
     let value = await matchGlobs(this.globs, key);
     if (Tree.isAsyncTree(value)) {
       value = Reflect.construct(this.constructor, [value]);
@@ -35,8 +31,8 @@ export default class GlobTree {
   }
 }
 
+// Convert the glob to a regular expression
 function matchGlob(glob, text) {
-  // Convert the glob to a regular expression
   const regexText = glob
     // Escape special regex characters
     .replace(/[+?^${}()|\[\]\\]/g, "\\$&")
@@ -49,10 +45,15 @@ function matchGlob(glob, text) {
 
 async function matchGlobs(globs, text) {
   let value;
-  for (const glob of await globs.keys()) {
+  for (let glob of await globs.keys()) {
     if (typeof glob !== "string") {
       continue;
-    } else if (glob !== globstar && matchGlob(glob, text)) {
+    }
+
+    // Remove trailing slash if it exists
+    glob = trailingSlash.remove(glob);
+
+    if (glob !== globstar && matchGlob(glob, text)) {
       value = await globs.get(glob);
       if (value !== undefined) {
         break;

package/src/misc/treeDot.js

@@ -3,6 +3,7 @@ import {
   isPlainObject,
   isStringLike,
   toString,
+  trailingSlash,
 } from "@weborigami/async-tree";
 import * as serialize from "../common/serialize.js";
 import { keySymbol } from "../common/utilities.js";
@@ -49,7 +50,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
   // Draw edges and collect labels for the nodes they lead to.
   let nodes = new Map();
   for (const key of await tree.keys()) {
-    const destPath = nodePath ? `${nodePath}/${key}` : key;
+    const destPath = nodePath ? `${trailingSlash.add(nodePath)}${key}` : key;
     const arc = `  "${nodePath}" -> "${destPath}" [label="${key}"];`;
     result.push(arc);
 
@@ -163,7 +164,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
     const label = `label="${icon}${text}"`;
     const color = node.isError ? `; color="red"` : "";
     const fill = node.isError ? `; fillcolor="#FFF4F4"` : "";
-    const destPath = nodePath ? `${nodePath}/${key}` : key;
+    const destPath = nodePath ? `${trailingSlash.add(nodePath)}${key}` : key;
     const url = createLinks ? `; URL="${destPath}"` : "";
     result.push(`  "${destPath}" [${label}${color}${fill}${url}];`);
   }

package/src/server/constructResponse.js

@@ -32,16 +32,6 @@ 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}`);
 
-  let mediaType;
-  if (resource.mediaType) {
-    // Resource indicates its own media type.
-    mediaType = resource.mediaType;
-  } else {
-    // Infer expected media type from file extension on request URL.
-    const extension = extname(url.pathname).toLowerCase();
-    mediaType = extension ? mediaTypeForExtension[extension] : undefined;
-  }
-
   if (!url.pathname.endsWith("/") && Tree.isTreelike(resource)) {
     // Treelike resource: redirect to its index page.
     const Location = `${url.pathname}/`;
@@ -57,6 +47,16 @@ export default async function constructResponse(request, resource) {
     resource = await resource.pack();
   }
 
+  let mediaType;
+  if (resource.mediaType) {
+    // Resource indicates its own media type.
+    mediaType = resource.mediaType;
+  } else {
+    // Infer expected media type from file extension on request URL.
+    const extension = extname(url.pathname).toLowerCase();
+    mediaType = extension ? mediaTypeForExtension[extension] : undefined;
+  }
+
   if (
     (mediaType === "application/json" || mediaType === "text/yaml") &&
     !isStringLike(resource)

package/src/server/parsePostData.js

@@ -0,0 +1,35 @@
+import { toString } from "@weborigami/async-tree";
+
+export default async function parsePostData(request) {
+  const data = await getPostData(request);
+  const type = request.headers["content-type"];
+  switch (type) {
+    case "application/json":
+      return JSON.parse(data);
+
+    case "application/x-www-form-urlencoded":
+      const params = new URLSearchParams(data);
+      return Object.fromEntries(params);
+
+    case "text/plain":
+      return toString(data);
+
+    default:
+      return data;
+  }
+}
+
+function getPostData(request) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    request.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    request.on("end", () => {
+      resolve(body);
+    });
+    request.on("error", (error) => {
+      reject(error);
+    });
+  });
+}

package/src/server/server.js

@@ -2,6 +2,7 @@ import { ObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
 import { formatError } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
+import parsePostData from "./parsePostData.js";
 
 /**
  * Copy a constructed response to a ServerResponse. Return true if the response
@@ -81,13 +82,16 @@ export async function handleRequest(request, response, tree) {
       ? extendTreeScopeWithParams(tree, url)
       : tree;
 
+  const data = request.method === "POST" ? await parsePostData(request) : null;
+
   // Ask the tree for the resource with those keys.
   let resource;
   try {
     resource = await Tree.traverse(extendedTree, ...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 = await resource();
+      resource = data ? await resource(data) : await resource();
     }
   } catch (/** @type {any} */ error) {
     respondWithError(response, error);
@@ -111,8 +115,16 @@ function keysFromUrl(url) {
   const parts = url.pathname.split(/\/!/);
 
   // Split everything before the first command by slashes and decode those.
-  const path = parts.shift();
+  let path = parts.shift();
+  if (parts.length > 0) {
+    // HACK: Add back trailing slash that was removed by split
+    path += "/";
+  }
   const pathKeys = keysFromPath(path).map((key) => decodeURIComponent(key));
+  if (parts.length > 0 && pathKeys.at(-1) === "") {
+    // HACK part 2: Remove empty string that was added for trailing slash
+    pathKeys.pop();
+  }
 
   // If there are no commands, and the path ends with a trailing slash, the
   // final key will be an empty string. Change that to "index.html".