@sanity/workbench 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/system.js

@@ -1,10 +1,117 @@
-import { getAuthState, logout, AuthStateType, getClient, createSanityInstance } from "@sanity/sdk";
-import { fromObservable, fromPromise, setup, assign, sendParent, fromCallback, sendTo, raise } from "xstate";
-import "./_chunks-es/studio.js";
+import { fromPromise, setup, assign, sendParent, fromObservable, fromCallback, enqueueActions, sendTo, raise } from "xstate";
 import { logger } from "./_chunks-es/index.js";
 import { createInstance } from "@sanity/federation/runtime";
 import { log } from "@sanity/federation/runtime/plugins/log";
+import { getAuthState, logout, AuthStateType, getClient, createSanityInstance } from "@sanity/sdk";
+import "./_chunks-es/studio.js";
 import { createSessionId, createBatchedStore } from "@sanity/telemetry";
+async function loadRemoteModule(instance, { moduleId, entry }) {
+  const name = moduleId.slice(0, moduleId.indexOf("/"));
+  return instance.registerRemotes([{ name, entry }]), await instance.loadRemote(moduleId) ?? null;
+}
+async function loadFederatedModule(instance, ref) {
+  try {
+    return await loadRemoteModule(instance, ref);
+  } catch (error) {
+    return logger.error(`Failed to load federated module "${ref.moduleId}"`, error), null;
+  }
+}
+class ModuleShapeError extends Error {
+  constructor(remoteId) {
+    super(`Remote "${remoteId}" did not expose a render function`);
+  }
+}
+class ModuleLoadError extends Error {
+  constructor(remoteId) {
+    super(`Remote module "${remoteId}" failed to load`);
+  }
+}
+const loadLogic = fromPromise(async ({ input }) => {
+  const remoteModule = await loadRemoteModule(input.instance, {
+    moduleId: input.moduleId,
+    entry: input.entry
+  });
+  if (remoteModule == null)
+    throw new ModuleLoadError(input.moduleId);
+  return remoteModule;
+}), remoteLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    tags: {}
+  },
+  actors: {
+    load: loadLogic
+  },
+  actions: {
+    setModule: assign({
+      module: (_, params) => params.module,
+      error: () => null
+    }),
+    setError: assign({
+      module: () => null,
+      error: (_, params) => normaliseError(params.error)
+    })
+  }
+}).createMachine({
+  id: "remote",
+  initial: "loading",
+  context: ({ input }) => ({
+    ...input,
+    module: null,
+    error: null
+  }),
+  states: {
+    loading: {
+      tags: ["loading"],
+      invoke: {
+        src: "load",
+        input: ({ context }) => ({
+          moduleId: context.moduleId,
+          entry: context.entry,
+          instance: context.instance
+        }),
+        onDone: {
+          target: "loaded",
+          actions: [
+            {
+              type: "setModule",
+              params: ({ event }) => ({ module: event.output })
+            }
+          ]
+        },
+        onError: {
+          target: "error",
+          actions: [
+            {
+              type: "setError",
+              params: ({ event }) => ({ error: event.error })
+            }
+          ]
+        }
+      }
+    },
+    loaded: {
+      tags: ["ready"],
+      entry: sendParent(({ context }) => ({
+        type: "remote.settled",
+        moduleId: context.moduleId,
+        status: "loaded"
+      }))
+    },
+    error: {
+      tags: ["failed"],
+      entry: sendParent(({ context }) => ({
+        type: "remote.settled",
+        moduleId: context.moduleId,
+        status: "error"
+      }))
+    }
+  }
+});
+function normaliseError(error) {
+  return error instanceof Error ? { message: error.message, cause: error } : { message: String(error), cause: error };
+}
 const authStateLogic = fromObservable(
   ({ input }) => getAuthState(input.instance).observable
 ), logoutActorLogic = fromPromise(async ({ input }) => {
@@ -200,153 +307,236 @@ const authStateLogic = fromObservable(
       log2.debug("action", event.action);
       break;
   }
-};
-class ModuleShapeError extends Error {
-  constructor(remoteId) {
-    super(`Remote "${remoteId}" did not expose a render function`);
-  }
-}
-const REMOTE_MODULE = "App", loadLogic = fromPromise(
-  async ({ input }) => {
-    input.instance.registerRemotes([{ name: input.id, entry: input.entry }]);
-    const remoteModule = await input.instance.loadRemote(
-      `${input.id}/${REMOTE_MODULE}`
-    );
-    if (!remoteModule || typeof remoteModule.render != "function")
-      throw new ModuleShapeError(input.id);
-    return remoteModule;
-  }
-), remoteLogic = setup({
+}, remotesLogic = setup({
   types: {
     input: {},
     context: {},
-    tags: {}
+    events: {}
   },
   actors: {
-    load: loadLogic
+    remote: remoteLogic
+  },
+  guards: {
+    remoteNotKnown: ({ context }, params) => !context.children.has(params.moduleId)
   },
   actions: {
-    setModule: assign({
-      module: (_, params) => params.module,
-      error: () => null
-    }),
-    setError: assign({
-      module: () => null,
-      error: (_, params) => normaliseError(params.error)
+    spawnRemote: assign({
+      children: ({ context, spawn }, params) => {
+        const ref = spawn("remote", {
+          id: params.moduleId,
+          systemId: `remotes.${params.moduleId}`,
+          input: {
+            moduleId: params.moduleId,
+            entry: params.entry,
+            instance: context.instance
+          }
+        });
+        return new Map(context.children).set(params.moduleId, ref);
+      }
     })
   }
 }).createMachine({
-  id: "remote",
-  initial: "loading",
+  id: "remotes",
   context: ({ input }) => ({
-    ...input,
-    module: null,
-    error: null
+    instance: input.instance,
+    children: /* @__PURE__ */ new Map()
   }),
+  on: {
+    "remote.load.request": {
+      guard: {
+        type: "remoteNotKnown",
+        params: ({ event }) => ({ moduleId: event.moduleId })
+      },
+      actions: [
+        {
+          type: "spawnRemote",
+          params: ({ event }) => ({
+            moduleId: event.moduleId,
+            entry: event.entry
+          })
+        }
+      ]
+    },
+    // Reserved for future supervision/retry. Forwarded by per-remote
+    // children on entry to `loaded` or `error`; currently a no-op so the
+    // event is part of the typed surface rather than a silent unknown.
+    "remote.settled": {}
+  }
+}), SERVICES_MODULE = "services", runWorker = fromCallback(({ input }) => {
+  let worker, blobUrl;
+  try {
+    const bootstrap = `import(${JSON.stringify(input.workerUrl)})`;
+    blobUrl = URL.createObjectURL(
+      new Blob([bootstrap], { type: "text/javascript" })
+    ), worker = new Worker(blobUrl, { type: "module" }), worker.addEventListener("message", (event) => {
+      if (event.data?.kind === "workbench.worker.error")
+        logger.error(
+          `Service "${input.key}" worker error`,
+          event.data.payload?.message
+        );
+      else if (event.data?.kind === "workbench.worker.log") {
+        const { level, message } = event.data.payload ?? {};
+        ({
+          warn: logger.warn,
+          error: logger.error,
+          debug: logger.debug
+        }[level] ?? logger.info)(
+          `[service:${input.serviceName}] ${message ?? ""}`
+        );
+      }
+    }), worker.addEventListener("error", (event) => {
+      logger.error(
+        `Service "${input.key}" worker error: ${event.message || String(event)}`
+      );
+    });
+  } catch (error) {
+    logger.error(`Service "${input.key}" failed to start its worker`, error);
+  }
+  return () => {
+    try {
+      worker?.postMessage({ kind: "workbench.worker.terminate" });
+    } finally {
+      worker?.terminate(), blobUrl && URL.revokeObjectURL(blobUrl);
+    }
+  };
+}), serviceLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    tags: {}
+  },
+  actors: {
+    loadInterface: remoteLogic,
+    runWorker
+  }
+}).createMachine({
+  id: "service",
+  initial: "loading",
+  context: ({ input }) => ({ ...input, workerUrl: null }),
+  // The invoked loader `sendParent`s a `remote.settled` on settle; this machine
+  // reacts via `onSnapshot` instead, so the event is a no-op here.
+  on: { "remote.settled": {} },
   states: {
     loading: {
       tags: ["loading"],
       invoke: {
-        src: "load",
+        id: "loader",
+        src: "loadInterface",
         input: ({ context }) => ({
-          id: context.id,
+          moduleId: `${context.appId}/${SERVICES_MODULE}/${context.serviceName}`,
           entry: context.entry,
           instance: context.instance
         }),
-        onDone: {
-          target: "loaded",
-          actions: [
-            {
-              type: "setModule",
-              params: ({ event }) => ({ module: event.output })
-            }
-          ]
-        },
-        onError: {
-          target: "error",
-          actions: [
-            {
-              type: "setError",
-              params: ({ event }) => ({ error: event.error })
+        onSnapshot: [
+          {
+            // Loaded and exposing a bundle URL → run it.
+            guard: ({ event }) => {
+              const module = event.snapshot.context.module;
+              return event.snapshot.hasTag("ready") && typeof module?.url == "string";
+            },
+            target: "running",
+            actions: assign({
+              workerUrl: ({ context, event }) => {
+                const module = event.snapshot.context.module;
+                return new URL(module.url, new URL(context.entry).origin).href;
+              }
+            })
+          },
+          {
+            // Load failed, or loaded without a usable URL → no worker.
+            guard: ({ event }) => {
+              const module = event.snapshot.context.module;
+              return event.snapshot.hasTag("failed") || event.snapshot.hasTag("ready") && typeof module?.url != "string";
+            },
+            target: "error",
+            // A worker has no UI surface (unlike a view's error boundary), so a
+            // failed load would otherwise be silent — log it through the host.
+            actions: ({ context, event }) => {
+              const cause = event.snapshot.context.error?.message;
+              logger.error(
+                `Service "${context.key}" failed to load its worker${cause ? `: ${cause}` : ""}`
+              );
             }
-          ]
-        }
+          }
+        ]
       }
     },
-    loaded: {
-      tags: ["ready"],
-      entry: sendParent(({ context }) => ({
-        type: "remote.settled",
-        id: context.id,
-        status: "loaded"
-      }))
+    running: {
+      tags: ["running"],
+      invoke: {
+        src: "runWorker",
+        input: ({ context }) => ({
+          key: context.key,
+          serviceName: context.serviceName,
+          // `workerUrl` is set on entry to `running` from `loading`'s output.
+          workerUrl: context.workerUrl
+        })
+      }
     },
     error: {
-      tags: ["failed"],
-      entry: sendParent(({ context }) => ({
-        type: "remote.settled",
-        id: context.id,
-        status: "error"
-      }))
+      tags: ["failed"]
     }
   }
 });
-function normaliseError(error) {
-  return error instanceof Error ? { message: error.message, cause: error } : { message: String(error), cause: error };
+function serviceKey(appId, serviceName) {
+  return `${appId}:${serviceName}`;
 }
-const remotesLogic = setup({
+const servicesLogic = setup({
   types: {
+    input: {},
     context: {},
     events: {}
   },
   actors: {
-    remote: remoteLogic
-  },
-  guards: {
-    remoteNotKnown: ({ context }, params) => !context.children.has(params.id)
+    service: serviceLogic
   },
   actions: {
-    spawnRemote: assign({
-      children: ({ context, spawn }, params) => {
-        const ref = spawn("remote", {
-          id: params.id,
-          systemId: `remotes.${params.id}`,
-          input: {
-            id: params.id,
-            entry: params.entry,
-            instance: context.instance
-          }
-        });
-        return new Map(context.children).set(params.id, ref);
-      }
+    /**
+     * Reconcile the running workers against the desired set: spawn the ones not
+     * yet running, stop (and forget) the ones no longer declared.
+     */
+    syncServices: enqueueActions(({ context, event, enqueue }) => {
+      const desired = new Map(
+        event.services.map((service) => [
+          serviceKey(service.appId, service.serviceName),
+          service
+        ])
+      );
+      for (const [key, ref] of context.children)
+        desired.has(key) || enqueue.stopChild(ref);
+      enqueue.assign({
+        children: ({ context: ctx, spawn }) => {
+          const next = /* @__PURE__ */ new Map();
+          for (const [key, ref] of ctx.children)
+            desired.has(key) && next.set(key, ref);
+          for (const [key, service] of desired)
+            next.has(key) || next.set(
+              key,
+              spawn("service", {
+                id: key,
+                systemId: `services.${key}`,
+                input: {
+                  key,
+                  appId: service.appId,
+                  serviceName: service.serviceName,
+                  entry: service.entry,
+                  instance: ctx.instance
+                }
+              })
+            );
+          return next;
+        }
+      });
     })
   }
 }).createMachine({
-  id: "remotes",
-  context: () => ({
-    instance: createInstance({
-      name: "workbench-applications",
-      plugins: [log(logger.debug)]
-    }),
+  id: "services",
+  context: ({ input }) => ({
+    instance: input.instance,
     children: /* @__PURE__ */ new Map()
   }),
   on: {
-    "remote.load.request": {
-      guard: {
-        type: "remoteNotKnown",
-        params: ({ event }) => ({ id: event.id })
-      },
-      actions: [
-        {
-          type: "spawnRemote",
-          params: ({ event }) => ({ id: event.id, entry: event.entry })
-        }
-      ]
-    },
-    // Reserved for future supervision/retry. Forwarded by per-remote
-    // children on entry to `loaded` or `error`; currently a no-op so the
-    // event is part of the typed surface rather than a silent unknown.
-    "remote.settled": {}
+    "services.sync": { actions: "syncServices" }
   }
 }), DEFAULT_PREFERRED_COLOR_SCHEME = "system", DEFAULT_OS_COLOR_SCHEME = "light", resolveColorScheme = (preferred, osColorScheme) => preferred === "system" ? osColorScheme : preferred, adapterBridgeLogic = fromCallback(({ input: adapter, sendBack, receive }) => {
   if (!adapter) return;
@@ -555,7 +745,8 @@ const remotesLogic = setup({
     auth: authLogic,
     telemetry: telemetryLogic,
     systemPreferences: systemPreferencesLogic,
-    remotes: remotesLogic
+    remotes: remotesLogic,
+    services: servicesLogic
   },
   guards: {
     hasTag: (_, params) => params.hasTag
@@ -574,6 +765,10 @@ const remotesLogic = setup({
   id: "os",
   context: ({ input }) => ({
     instance: createSanityInstance(),
+    federationInstance: createInstance({
+      name: "workbench-applications",
+      plugins: [log(logger.debug)]
+    }),
     userProperties: {
       version: input.version,
       organizationId: input.organizationId,
@@ -639,7 +834,14 @@ const remotesLogic = setup({
     {
       id: "remotes",
       systemId: "remotes",
-      src: "remotes"
+      src: "remotes",
+      input: ({ context }) => ({ instance: context.federationInstance })
+    },
+    {
+      id: "services",
+      systemId: "services",
+      src: "services",
+      input: ({ context }) => ({ instance: context.federationInstance })
     }
   ],
   states: {
@@ -678,7 +880,9 @@ function createOSOptions(input) {
   };
 }
 export {
+  ModuleShapeError,
   createOSOptions,
+  loadFederatedModule,
   os
 };
 //# sourceMappingURL=system.js.map