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

package/src/system/services.machine.ts

@@ -0,0 +1,120 @@
+import { type FederationInstance } from "@sanity/federation/runtime";
+import { type ActorRefFrom, enqueueActions, setup } from "xstate";
+
+import { serviceLogic } from "./service.machine";
+
+/** The shared federation instance, supplied by the root machine. */
+type ServicesInput = {
+  instance: FederationInstance;
+};
+
+type ServicesContext = {
+  instance: FederationInstance;
+  children: Map<string, ActorRefFrom<typeof serviceLogic>>;
+};
+
+/**
+ * The full set of background services the workbench should currently be
+ * running, re-sent whenever the application list — or any app's declared
+ * interfaces — changes. The supervisor reconciles its children against it.
+ */
+type ServicesEvent = {
+  type: "services.sync";
+  services: ReadonlyArray<{
+    appId: string;
+    serviceName: string;
+    entry: string;
+  }>;
+};
+
+/** Stable child key for a service: `${appId}:${serviceName}`. */
+function serviceKey(appId: string, serviceName: string): string {
+  return `${appId}:${serviceName}`;
+}
+
+/**
+ * Supervisor machine for background service workers.
+ *
+ * Uses the shared {@link FederationInstance} (supplied by the root machine and
+ * shared with `remotes`, so an app's remote is registered once for both its
+ * views and its workers) and spawns one {@link serviceLogic} child per
+ * `(app, service)`. Invoked at the root of the OS machine for inspector
+ * visibility — boot does not gate on it.
+ *
+ * On every `services.sync` it reconciles its children against the desired set:
+ * a newly-declared worker is spawned, and a worker whose declaration was
+ * removed (e.g. deleted from `sanity.cli.ts` during dev — FR-024) is stopped,
+ * which disposes its `runWorker` callback and terminates the Web Worker. A
+ * service `src` edit still triggers a Vite full page reload (workers have no
+ * HMR boundary), which reboots the workbench and respawns with the new code.
+ *
+ * @internal
+ */
+export const servicesLogic = setup({
+  types: {
+    input: {} as ServicesInput,
+    context: {} as ServicesContext,
+    events: {} as ServicesEvent,
+  },
+  actors: {
+    service: serviceLogic,
+  },
+  actions: {
+    /**
+     * 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,
+        ]),
+      );
+
+      // Stop + forget workers whose declaration was removed. Stopping the child
+      // disposes its `runWorker` callback, which terminates the Web Worker.
+      for (const [key, ref] of context.children) {
+        if (!desired.has(key)) enqueue.stopChild(ref);
+      }
+
+      enqueue.assign({
+        children: ({ context: ctx, spawn }) => {
+          const next = new Map<string, ActorRefFrom<typeof serviceLogic>>();
+          // Keep the children still declared.
+          for (const [key, ref] of ctx.children) {
+            if (desired.has(key)) next.set(key, ref);
+          }
+          // Spawn the newly-declared ones.
+          for (const [key, service] of desired) {
+            if (next.has(key)) continue;
+            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: "services",
+  context: ({ input }) => ({
+    instance: input.instance,
+    children: new Map(),
+  }),
+  on: {
+    "services.sync": { actions: "syncServices" },
+  },
+});