@weborigami/language 0.6.17 → 0.7.0-beta.2

package/src/runtime/enableValueCaching.js

@@ -0,0 +1,192 @@
+import { AsyncMap, isPlainObject, SyncMap, Tree } from "@weborigami/async-tree";
+import AsyncCacheTransform from "./AsyncCacheTransform.js";
+import { cachePathSymbol } from "./symbols.js";
+import SyncCacheTransform from "./SyncCacheTransform.js";
+import systemCache from "./systemCache.js";
+import SystemCacheMap from "./SystemCacheMap.js";
+
+// For detecting async functions
+const AsyncFunction = async function () {}.constructor;
+
+/**
+ * Given a maplike object whose values can be cached, enable caching. This may
+ * apply a caching transform, and sets a cache path on the object so that it can
+ * use as the prefix for cache paths.
+ *
+ * Note: this typically destructively modifies the given value.
+ *
+ * @param {any} value
+ * @param {string} cachePath
+ */
+export default function enableValueCaching(value, cachePath) {
+  if (!(typeof value === "object" || typeof value === "function")) {
+    // Don't need to apply caching to primitive value
+    return value;
+  }
+
+  const cacheable =
+    value[cachePathSymbol] === undefined && Tree.isMaplike(value);
+  if (cacheable) {
+    if (isPlainObject(value)) {
+      // Expression objects do their own caching
+      // TODO: What if it's some other kind of plain object?
+      markCacheable(value, cachePath);
+    } else if (Array.isArray(value)) {
+      // Cache arrays
+      markCacheable(value, cachePath);
+    } else if (value instanceof Function) {
+      // Cache a function
+      value = cacheFunction(value, cachePath);
+    } else if (
+      isTransformApplied(SyncCacheTransform, value) ||
+      isTransformApplied(AsyncCacheTransform, value)
+    ) {
+      // Already has caching transform applied; just mark cacheable
+      markCacheable(value, cachePath);
+    } else {
+      // Other maplike; convert to a Map/AsyncMap
+      value = Tree.from(value);
+      if (value instanceof Map) {
+        if (!(value instanceof SyncMap)) {
+          // Convert regular Map to SyncMap so we can extend it
+          value = new (SyncCacheTransform(SyncMap))(value);
+        } else {
+          // Cache a SyncMap
+          value = transformObject(SyncCacheTransform, value);
+        }
+      } else if (value instanceof AsyncMap) {
+        // Cache an AsyncMap
+        value = transformObject(AsyncCacheTransform, value);
+      }
+      markCacheable(value, cachePath);
+    }
+  }
+
+  return value;
+}
+
+/**
+ * Cache a function with arity 1 or greater that takes string arguments
+ *
+ * @param {Function} fn
+ * @param {string} cachePath
+ */
+export function cacheFunction(fn, cachePath) {
+  if (fn.length === 0) {
+    // Return as is
+    return fn;
+  }
+  let result;
+  if (fn instanceof AsyncFunction) {
+    // Return an async function that caches results for a unary argument
+    result = async (...args) => {
+      if (!allStringArguments(args)) {
+        // Run function in context of this cache path, but don't cache result
+        return systemCache.runInContextAsync(cachePath, () => fn(...args));
+      }
+      const keyCachePath = SystemCacheMap.joinPath(cachePath, args.join("/"));
+      let result = systemCache.getOrInsertComputedAsync(
+        keyCachePath,
+        async () => fn(...args),
+      );
+      result = enableValueCaching(result, keyCachePath);
+      return result;
+    };
+  } else {
+    // Return a sync function that caches results for a unary argument
+    result = (...args) => {
+      if (!allStringArguments(args)) {
+        // Run function in context of this cache path, but don't cache result
+        return systemCache.runInContext(cachePath, () => fn(...args));
+      }
+      const keyCachePath = SystemCacheMap.joinPath(cachePath, args.join("/"));
+      let result = systemCache.getOrInsertComputed(keyCachePath, () =>
+        fn(...args),
+      );
+      result = enableValueCaching(result, keyCachePath);
+      return result;
+    };
+  }
+  Object.defineProperty(result, "length", {
+    value: fn.length,
+    configurable: true,
+  });
+  markCacheable(result, cachePath);
+  return result;
+}
+
+// Non-string keys and non-empty strings can't be cached
+function allStringArguments(args) {
+  return (
+    args.length > 0 &&
+    args.every((arg) => typeof arg === "string" && arg.length > 0)
+  );
+}
+
+export function isTransformApplied(Transform, obj) {
+  let transformName = Transform.name;
+  if (!transformName) {
+    throw `isTransformApplied was called on an unnamed transform function, but a name is required.`;
+  }
+  if (transformName.endsWith("Transform")) {
+    transformName = transformName.slice(0, -9);
+  }
+  // Walk up prototype chain looking for a constructor with the same name as the
+  // transform. This is not a great test.
+  for (let proto = obj; proto; proto = Object.getPrototypeOf(proto)) {
+    if (proto.constructor.name === transformName) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function markCacheable(object, cachePath) {
+  Object.defineProperty(object, cachePathSymbol, {
+    configurable: true,
+    enumerable: false,
+    value: cachePath,
+  });
+}
+/**
+ * Apply a functional class mixin to an individual object instance.
+ *
+ * This works by create an intermediate class, creating an instance of that, and
+ * then setting the intermediate class's prototype to the given individual
+ * object. The resulting, extended object is then returned.
+ *
+ * This manipulation of the prototype chain is generally sound in JavaScript,
+ * with some caveats. In particular, the original object class cannot make
+ * direct use of private members; JavaScript will complain if the extended
+ * object does anything that requires access to those private members.
+ *
+ * @param {Function} Transform
+ * @param {any} obj
+ */
+export function transformObject(Transform, obj) {
+  // Apply the mixin to Object and instantiate that. The Object base class here
+  // is going to be cut out of the prototype chain in a moment; we just use
+  // Object as a convenience because its constructor takes no arguments.
+  const mixed = new (Transform(Object))();
+
+  // Find the highest prototype in the chain that was added by the class mixin.
+  // The mixin may have added multiple prototypes to the chain. Walk up the
+  // prototype chain until we hit Object.
+  let mixinProto = Object.getPrototypeOf(mixed);
+  while (Object.getPrototypeOf(mixinProto) !== Object.prototype) {
+    mixinProto = Object.getPrototypeOf(mixinProto);
+  }
+
+  // Redirect the prototype chain above the mixin to point to the original
+  // object. The mixed object now extends the original object with the mixin.
+  Object.setPrototypeOf(mixinProto, obj);
+
+  // Create a new constructor for this mixed object that reflects its prototype
+  // chain. Because we've already got the instance we want, we won't use this
+  // constructor now, but this can be used later to instantiate other objects
+  // that look like the mixed one.
+  mixed.constructor = Transform(obj.constructor);
+
+  // Return the mixed object.
+  return mixed;
+}

package/src/runtime/execute.js

@@ -1,5 +1,5 @@
 import { isUnpackable, Tree } from "@weborigami/async-tree";
-import asyncStorage from "./asyncStorage.js";
+import executionContext from "./executionContext.js";
 import "./interop.js";
 
 /**
@@ -68,7 +68,7 @@ export default async function execute(code, state = {}) {
   // Execute the function or traverse the map.
   let result;
   try {
-    result = await asyncStorage.run(
+    result = await executionContext.run(
       context,
       async () =>
         fn instanceof Function

package/src/runtime/executionContext.js

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/**
+ * The execute() function's context made available to async functions called
+ * during evaluation.
+ */
+export default new AsyncLocalStorage();

package/src/runtime/explainReferenceError.js

@@ -39,8 +39,13 @@ export default async function explainReferenceError(code, state) {
   let key;
   if (code[0] === ops.cache) {
     // External scope reference
-    const scopeCall = code[3].slice(1); // drop the ops.scope
-    const keys = scopeCall.map((part) => part[1]);
+    let refCall = code[2];
+    if (refCall[0] === ops.unpack) {
+      // Unwrap implied unpack
+      refCall = refCall[1];
+    }
+    const scopeArgs = refCall.slice(1); // get the scope reference arguments
+    const keys = scopeArgs.map((part) => part[1]);
     const path = pathFromKeys(keys);
 
     if (keys.length > 1) {

package/src/runtime/expressionObject.js

@@ -6,9 +6,13 @@ import {
   trailingSlash,
   Tree,
 } from "@weborigami/async-tree";
+import enableValueCaching from "./enableValueCaching.js";
 import execute from "./execute.js";
 import handleExtension from "./handleExtension.js";
 import { ops } from "./internal.js";
+import { cachePathSymbol } from "./symbols.js";
+import systemCache from "./systemCache.js";
+import SystemCacheMap from "./SystemCacheMap.js";
 
 export const KEY_TYPE = {
   STRING: 0, // Simple string key: `a: 1`
@@ -36,6 +40,7 @@ export default async function expressionObject(entries, state = {}) {
   if (parent !== null && !Tree.isMap(parent)) {
     throw new TypeError(`Parent must be a map or null`);
   }
+
   setParent(object, parent);
 
   // The object in Map form for use on the stack
@@ -51,17 +56,7 @@ export default async function expressionObject(entries, state = {}) {
     }
   }
 
-  // Second pass: redefine eager string-keyed properties with actual values.
-  for (const info of infos) {
-    if (
-      info.keyType === KEY_TYPE.STRING &&
-      info.valueType === VALUE_TYPE.EAGER
-    ) {
-      await redefineProperty(object, info);
-    }
-  }
-
-  // Third pass: define all computed properties. These may refer to the
+  // Second pass: define all computed properties. These may refer to the
   // properties we just defined.
   for (const info of infos) {
     if (info.keyType === KEY_TYPE.COMPUTED) {
@@ -73,15 +68,11 @@ export default async function expressionObject(entries, state = {}) {
     }
   }
 
-  // Fourth pass: redefine eager computed-keyed properties with actual values.
-  for (const info of infos) {
-    if (
-      info.keyType === KEY_TYPE.COMPUTED &&
-      info.valueType === VALUE_TYPE.EAGER
-    ) {
-      await redefineProperty(object, info);
-    }
-  }
+  // Third pass: retrieve eager properties, memoizing them on the object
+  const eagerKeys = infos
+    .filter((info) => info.valueType === VALUE_TYPE.EAGER)
+    .map((info) => info.key);
+  await Promise.all(eagerKeys.map((key) => object[key]));
 
   // Attach a keys method, where keys for primitive/eager properties with
   // maplike values get a trailing slash.
@@ -95,16 +86,6 @@ export default async function expressionObject(entries, state = {}) {
     writable: true,
   });
 
-  // TODO: If there are any getters, mark the object as async. Note: this code
-  // was added so that Tree.from() could know whether to return an ObjectMap or
-  // a hypothetical AsyncObjectMap, which in turn would let a map operation know
-  // whether to expect async property values. const hasGetters =
-  // infos.some((info) => info.valueType === VALUE_TYPE.GETTER); if (hasGetters)
-  // { Object.defineProperty(object, symbols.async, { configurable: true,
-  // enumerable: false, value: true, writable: true,
-  //   });
-  // }
-
   return object;
 }
 
@@ -112,6 +93,7 @@ export default async function expressionObject(entries, state = {}) {
  * Define a single property on the object
  */
 function defineProperty(object, propertyInfo, state, map) {
+  const { globals } = state;
   let { enumerable, hasExtension, key, value, valueType } = propertyInfo;
   if (valueType == VALUE_TYPE.PRIMITIVE) {
     // Define simple property
@@ -127,14 +109,54 @@ function defineProperty(object, propertyInfo, state, map) {
       configurable: true,
       enumerable,
       get: async () => {
+        // Execute the code to get the value of the property
+        const propertyCachePath = getPropertyCachePath(object, key);
+
         const newState = Object.assign({}, state, { object: map });
-        const result = await execute(value, newState);
-        return hasExtension ? handleExtension(result, key, map) : result;
+        let result = propertyCachePath
+          ? await systemCache.getOrInsertComputedAsync(propertyCachePath, () =>
+              execute(value, newState),
+            )
+          : await execute(value, newState);
+
+        if (hasExtension) {
+          // Handle extension
+          result = handleExtension(result, key, globals, map);
+        }
+
+        if (valueType === VALUE_TYPE.EAGER) {
+          // Memoize result on the object itself
+          Object.defineProperty(object, key, {
+            configurable: true,
+            enumerable,
+            value: result,
+            writable: true,
+          });
+        } else if (propertyCachePath) {
+          result = enableValueCaching(result, propertyCachePath);
+        }
+
+        return result;
       },
     });
   }
 }
 
+function getPropertyCachePath(object, key) {
+  // Follow parent chain looking for a parent that has caching enabled
+  let current = object;
+  while (current[cachePathSymbol] === undefined) {
+    current = current[symbols.parent];
+    if (!current) {
+      // Caching isn't enabled on this object tree
+      return null;
+    }
+  }
+
+  const cachePath = SystemCacheMap.joinPath(current[cachePathSymbol], key);
+  return cachePath;
+}
+
 /**
  * Return a normalized version of the property key for use in the keys() method.
  * Among other things, this adds trailing slashes to keys that correspond to
@@ -227,17 +249,3 @@ export function propertyInfo(key, value) {
 
   return { enumerable, hasExtension, key, keyType, value, valueType };
 }
-
-/**
- * Get the value of the indicated eager property and overwrite the property
- * definition with the actual value.
- */
-async function redefineProperty(object, info) {
-  const value = await object[info.key];
-  Object.defineProperty(object, info.key, {
-    configurable: true,
-    enumerable: info.enumerable,
-    value,
-    writable: true,
-  });
-}

package/src/runtime/handleExtension.js

@@ -8,7 +8,10 @@ import {
   trailingSlash,
 } from "@weborigami/async-tree";
 import getPackedPath from "../handlers/getPackedPath.js";
-import projectGlobals from "../project/projectGlobals.js";
+import mediaTypeExtensions from "../handlers/mediaTypeExtensions.json" with { type: "json" };
+import { cachePathSymbol } from "./symbols.js";
+import systemCache from "./systemCache.js";
+import SystemCacheMap from "./SystemCacheMap.js";
 
 /**
  * If the given value is packed (e.g., buffer) and the key is a string-like path
@@ -17,28 +20,33 @@ import projectGlobals from "../project/projectGlobals.js";
  *
  * @param {any} value
  * @param {any} key
+ * @param {any} handlers
  * @param {import("@weborigami/async-tree").SyncOrAsyncMap|null} [parent]
  */
-export default async function handleExtension(value, key, parent = null) {
-  if (isPacked(value) && isStringlike(key) && value.unpack === undefined) {
-    const hasSlash = trailingSlash.has(key);
-    if (hasSlash) {
-      key = trailingSlash.remove(key);
-    }
+export default function handleExtension(value, key, handlers, parent = null) {
+  if (
+    isPacked(value) &&
+    isStringlike(key) &&
+    value.unpack === undefined &&
+    handlers
+  ) {
+    const normalized = trailingSlash.remove(key);
 
     // Special cases: `.ori.<ext>` extensions are Origami documents
-    const extname = key.match(/\.ori\.\S+$/)
+    let extname = normalized.match(/\.ori\.\S+$/)
       ? ".oridocument"
-      : extension.extname(key);
+      : extension.extname(normalized);
+
+    if (!extname && /** @type {any} */ (value)?.mediaType) {
+      extname = extensionFromMediaType(/** @type {any} */ (value).mediaType);
+    }
+
     if (extname) {
       const handlerName = `${extname.slice(1)}_handler`;
-      const handlers = await projectGlobals(parent);
-      let handler = await handlers[handlerName];
-      if (handler) {
-        if (isUnpackable(handler)) {
-          // The extension handler itself needs to be unpacked
-          handler = await handler.unpack();
-        }
+      // Use `in` to look for handle so that, if the handler is a promise, we
+      // can still find it without awaiting it here.
+      if (handlerName in handlers) {
+        let handler = handlers[handlerName];
 
         // If the value is a primitive, box it so we can attach data to it.
         value = box(value);
@@ -51,9 +59,45 @@ export default async function handleExtension(value, key, parent = null) {
           setParent(value, parent);
         }
 
-        if (handler.unpack) {
-          value.unpack = wrapUnpack(handler.unpack, value, key, parent);
+        // Wrap the unpack function so it caches the unpacked value, and so we
+        // can add the file path to any errors the unpack function throws.
+        const filePath = getPackedPath(value, { key: normalized, parent });
+        let fileCachePath;
+        if (parent?.[cachePathSymbol]) {
+          fileCachePath = SystemCacheMap.joinPath(
+            parent[cachePathSymbol],
+            normalized,
+          );
+        } else {
+          fileCachePath = filePath;
         }
+        const unpackCachePath = trailingSlash.add(fileCachePath);
+        value.unpack = async () =>
+          systemCache.getOrInsertComputedAsync(unpackCachePath, async () => {
+            if (handler instanceof Promise) {
+              handler = await handler;
+            }
+            if (isUnpackable(handler)) {
+              // The extension handler itself needs to be unpacked
+              handler = await handler.unpack();
+            }
+
+            const unpacked = await handler.unpack(value, {
+              key: normalized,
+              parent,
+            });
+
+            // Now that we know the file was unpacked, we cache the file value
+            // itself so that subsequent requests for the file can be fulfilled
+            // from the cache. Doing this sort of manipulation outside of the
+            // cache doesn't feel great, but works.
+            const fileCacheEntry = systemCache.get(fileCachePath);
+            if (fileCacheEntry) {
+              fileCacheEntry.value = value;
+            }
+
+            return unpacked;
+          });
       }
     }
   }
@@ -61,20 +105,7 @@ export default async function handleExtension(value, key, parent = null) {
   return value;
 }
 
-// Wrap the unpack function so it's only called once per value, and so we can
-// add the file path to any errors it throws.
-function wrapUnpack(unpack, value, key, parent) {
-  let result;
-  return async () => {
-    if (!result) {
-      try {
-        result = await unpack(value, { key, parent });
-      } catch (/** @type {any} */ error) {
-        const filePath = getPackedPath(value, { key, parent });
-        const message = `Can't unpack ${filePath}\n${error.message}`;
-        throw new error.constructor(message, { cause: error });
-      }
-    }
-    return result;
-  };
+function extensionFromMediaType(mediaType) {
+  const essence = mediaType.split(";")[0].trim();
+  return mediaTypeExtensions[essence];
 }

package/src/runtime/interop.js

@@ -1,13 +1,13 @@
 import { interop } from "@weborigami/async-tree";
-import asyncStorage from "./asyncStorage.js";
 import { lineInfo } from "./errors.js";
+import executionContext from "./executionContext.js";
 
 /**
  * Inject our warning function into async-tree calls
  */
 interop.warn = function warn(...args) {
   console.warn(...args);
-  const context = asyncStorage.getStore();
+  const context = executionContext.getStore();
   const location = context?.code?.location;
   if (location) {
     console.warn(lineInfo(location));

package/src/runtime/mergeTrees.js

@@ -1,11 +1,11 @@
 import {
+  assignPropertyDescriptors,
   isPlainObject,
   isUnpackable,
   symbols,
   trailingSlash,
   Tree,
 } from "@weborigami/async-tree";
-import assignPropertyDescriptors from "./assignPropertyDescriptors.js";
 
 /**
  * Create a tree that's the result of merging the given trees.