@async/framework 0.7.0 → 0.9.0

package/src/server-entry.js

@@ -0,0 +1,20 @@
+import {
+  createApp as createBaseApp,
+  defineApp as defineBaseApp,
+  readSnapshot
+} from "./app.js";
+import { createServerRegistry } from "./server-registry.js";
+
+export function createApp(appOrDefinition = Async, options = {}) {
+  return createBaseApp(appOrDefinition, {
+    serverFactory: createServerRegistry,
+    ...options
+  });
+}
+
+export function defineApp(initial) {
+  return defineBaseApp(initial, { createRuntime: createApp });
+}
+
+export const Async = defineApp();
+export { readSnapshot };

package/src/server-registry.js

@@ -0,0 +1,97 @@
+import { readRequestContext } from "./request-context.js";
+import { attachRegistryInspection, createRegistryStore } from "./registry-store.js";
+import { assertServerId, createServerNamespace, createSignalReader } from "./server.js";
+
+export function createServerRegistry(initialMap = {}, options = {}) {
+  const registryStore = options.registry ?? createRegistryStore();
+  const type = options.type ?? "server";
+  const entries = registryStore._map(type);
+  const defaults = {};
+
+  const registry = attachRegistryInspection({
+    register(id, fn) {
+      assertServerId(id);
+      if (typeof fn !== "function") {
+        throw new TypeError(`Server function "${id}" must be a function.`);
+      }
+      if (entries.has(id)) {
+        throw new Error(`Server function "${id}" is already registered.`);
+      }
+      entries.set(id, fn);
+      return id;
+    },
+
+    registerMany(map) {
+      for (const [id, fn] of Object.entries(map ?? {})) {
+        registry.register(id, fn);
+      }
+      return registry;
+    },
+
+    unregister(id) {
+      assertServerId(id);
+      return entries.delete(id);
+    },
+
+    resolve(id) {
+      assertServerId(id);
+      return entries.get(id);
+    },
+
+    async run(id, args = [], context = {}) {
+      assertServerId(id);
+      const fn = registry.resolve(id);
+      if (!fn) {
+        throw new Error(`Server function "${id}" is not registered.`);
+      }
+
+      let runContext;
+      const server = createServerNamespace((childId, childArgs, childContext = {}) => {
+        return registry.run(childId, childArgs, { ...runContext, ...childContext });
+      }, {}, () => runContext);
+
+      const mergedContext = mergeRequestContext({
+        ...defaults,
+        ...context,
+        cache: defaults.cache ?? context.cache
+      });
+
+      runContext = {
+        ...mergedContext,
+        id,
+        args,
+        input: mergedContext.input,
+        signals: createSignalReader(mergedContext.signals),
+        abort: mergedContext.abort,
+        cache: mergedContext.cache,
+        server
+      };
+
+      return fn.call(runContext, ...args);
+    },
+
+    _setContext(context = {}) {
+      Object.assign(defaults, context);
+      return registry;
+    },
+
+    _adoptMany() {
+      return registry;
+    }
+  }, registryStore, type);
+
+  registry.registerMany(initialMap);
+  return createServerNamespace((id, args, context) => registry.run(id, args, context), registry, () => defaults);
+}
+
+function mergeRequestContext(context) {
+  const requestContext = readRequestContext(context.requestContext);
+  return {
+    ...context,
+    requestContext,
+    request: requestContext.request ?? context.request,
+    headers: requestContext.headers ?? context.headers,
+    cookies: requestContext.cookies ?? context.cookies,
+    locals: requestContext.locals ?? context.locals
+  };
+}

package/src/server.js

@@ -1,91 +1,7 @@
-import { attachRegistryInspection, createRegistryStore } from "./registry-store.js";
-
 const serverEnvelopeKeys = new Set(["value", "signals", "boundary", "html", "redirect", "error"]);
 const appliedServerResult = Symbol.for("@async/framework.appliedServerResult");
 const appliedServerValues = new WeakSet();
 
-export function createServerRegistry(initialMap = {}, options = {}) {
-  const registryStore = options.registry ?? createRegistryStore();
-  const type = options.type ?? "server";
-  const entries = registryStore._map(type);
-  const defaults = {};
-
-  const registry = attachRegistryInspection({
-    register(id, fn) {
-      assertServerId(id);
-      if (typeof fn !== "function") {
-        throw new TypeError(`Server function "${id}" must be a function.`);
-      }
-      if (entries.has(id)) {
-        throw new Error(`Server function "${id}" is already registered.`);
-      }
-      entries.set(id, fn);
-      return id;
-    },
-
-    registerMany(map) {
-      for (const [id, fn] of Object.entries(map ?? {})) {
-        registry.register(id, fn);
-      }
-      return registry;
-    },
-
-    unregister(id) {
-      assertServerId(id);
-      return entries.delete(id);
-    },
-
-    resolve(id) {
-      assertServerId(id);
-      return entries.get(id);
-    },
-
-    async run(id, args = [], context = {}) {
-      assertServerId(id);
-      const fn = registry.resolve(id);
-      if (!fn) {
-        throw new Error(`Server function "${id}" is not registered.`);
-      }
-
-      let runContext;
-      const server = createServerNamespace((childId, childArgs, childContext = {}) => {
-        return registry.run(childId, childArgs, { ...runContext, ...childContext });
-      }, {}, () => runContext);
-
-      const mergedContext = {
-        ...defaults,
-        ...context,
-        cache: defaults.cache ?? context.cache
-      };
-
-      runContext = {
-        ...mergedContext,
-        id,
-        args,
-        input: mergedContext.input,
-        signals: createSignalReader(mergedContext.signals),
-        abort: mergedContext.abort,
-        cache: mergedContext.cache,
-        server
-      };
-
-      return fn.call(runContext, ...args);
-    },
-
-    _setContext(context = {}) {
-      Object.assign(defaults, context);
-      return registry;
-    },
-
-    _adoptMany() {
-      return registry;
-    }
-  }, registryStore, type);
-
-  registry.registerMany(initialMap);
-  return createServerNamespace((id, args, context) => registry.run(id, args, context), registry, () => defaults);
-}
-
 export function createServerProxy({
   endpoint = "/__async/server",
   fetch: fetchImpl = globalThis.fetch?.bind(globalThis),
@@ -93,13 +9,14 @@ export function createServerProxy({
   loader,
   router,
   cache,
+  scheduler,
   headers = {}
 } = {}) {
   if (typeof fetchImpl !== "function") {
     throw new TypeError("createServerProxy(...) requires fetch to be available.");
   }
 
-  const defaults = { signals, loader, router, cache };
+  const defaults = { signals, loader, router, cache, scheduler };
 
   async function run(id, args = [], context = {}) {
     assertServerId(id);
@@ -229,7 +146,7 @@ export function defaultInput(context = {}) {
   };
 }
 
-function createServerNamespace(run, root = {}, contextProvider = () => ({})) {
+export function createServerNamespace(run, root = {}, contextProvider = () => ({})) {
   const cache = new Map();
 
   function namespace(parts) {
@@ -311,7 +228,7 @@ function readSignal(signals, path) {
   return signals.get(path);
 }
 
-function createSignalReader(signals) {
+export function createSignalReader(signals) {
   if (!signals || typeof signals.get === "function") {
     return signals;
   }
@@ -433,7 +350,7 @@ function toError(value) {
   return new Error(String(value));
 }
 
-function assertServerId(id) {
+export function assertServerId(id) {
   if (typeof id !== "string" || id.length === 0) {
     throw new TypeError("Server function id must be a non-empty string.");
   }

package/src/signals.js

@@ -96,7 +96,8 @@ export function computed(fn) {
           server: registry._context?.().server,
           router: registry._context?.().router,
           loader: registry._context?.().loader,
-          cache: registry._context?.().cache
+          cache: registry._context?.().cache,
+          scheduler: registry._context?.().scheduler
         }));
       });
     }
@@ -124,6 +125,8 @@ export function createSignalRegistry(initialMap = {}, options = {}) {
   const registryCleanups = new Map();
   const runtimeContext = {};
   const boundEntries = new Set();
+  let subscriptionCounter = 0;
+  let effectCounter = 0;
 
   const registry = attachRegistryInspection({
     register(id, signalLike) {
@@ -199,17 +202,21 @@ export function createSignalRegistry(initialMap = {}, options = {}) {
       return createRef(registry, id);
     },
 
-    subscribe(path, fn) {
+    subscribe(path, fn, options = {}) {
       if (typeof fn !== "function") {
         throw new TypeError("subscribe(path, fn) requires a function.");
       }
       const parsed = parsePath(path, entries);
       const entry = requireEntry(entries, parsed.id);
+      const subscriptionId = ++subscriptionCounter;
       return entry.subscribe(() => {
-        fn(registry.get(parsed.path), {
+        scheduleCallback(() => fn(registry.get(parsed.path), {
           id: parsed.id,
           path: parsed.path,
           signal: entry
+        }), {
+          ...options,
+          key: options.key ?? `signal:${parsed.path}:${subscriptionId}`
         });
       });
     },
@@ -227,10 +234,12 @@ export function createSignalRegistry(initialMap = {}, options = {}) {
       return registry.ref(id);
     },
 
-    effect(fn) {
+    effect(fn, options = {}) {
       let cleanup;
       let dependencyCleanups = [];
       let stopped = false;
+      const scheduler = options.scheduler;
+      const effectId = ++effectCounter;
 
       const run = () => {
         if (stopped) {
@@ -249,10 +258,22 @@ export function createSignalRegistry(initialMap = {}, options = {}) {
           server: runtimeContext.server,
           router: runtimeContext.router,
           loader: runtimeContext.loader,
-          cache: runtimeContext.cache
+          cache: runtimeContext.cache,
+          scheduler: runtimeContext.scheduler
         }));
         cleanup = outcome.value;
-        dependencyCleanups = outcome.dependencies.map((dependency) => registry.subscribe(dependency, run));
+        dependencyCleanups = outcome.dependencies.map((dependency) => registry.subscribe(dependency, scheduleRun));
+      };
+
+      const scheduleRun = () => {
+        if (!scheduler) {
+          run();
+          return;
+        }
+        scheduler.enqueue(options.phase ?? "effect", run, {
+          scope: options.scope,
+          key: options.key ?? `effect:${effectId}`
+        });
       };
 
       run();
@@ -329,6 +350,17 @@ export function createSignalRegistry(initialMap = {}, options = {}) {
       registryCleanups.set(id, cleanup);
     }
   }
+
+  function scheduleCallback(fn, options = {}) {
+    const scheduler = options.scheduler;
+    if (!scheduler || options.phase === "sync") {
+      return fn();
+    }
+    return scheduler.enqueue(options.phase ?? "effect", fn, {
+      scope: options.scope,
+      key: options.key
+    });
+  }
 }
 
 function normalizeSignal(signalLike) {