@sanity/workflow-studio 0.8.0 → 0.9.0

package/dist/index.js

@@ -1,180 +1,112 @@
-import { instanceGuardQuery, contentDraftFallback, contentReleaseName, WORKFLOW_INSTANCE_TYPE, ENGINE_API_VERSION, createEngine, EXECUTION_KINDS } from "@sanity/workflow-engine";
+import { ensureDocumentExists, datasetResourceId, useKeyed } from "@sanity/workflow-react/observer";
 
-import { sameDataset, ensureDocumentExists, validatedInstancesStore, validatedGuardsStore, combineGuardStores, combineDocStores, classifyRef, validatedInstanceStore, datasetResourceId, useKeyed } from "@sanity/workflow-react/observer";
-
-import { sdkInstancesStore, sdkGuardStore, sdkContentDocStore, sdkInstanceDocStore } from "@sanity/workflow-sdk/observer";
+import { makeSdkObserver } from "@sanity/workflow-sdk/observer";
 
 import { createSanityInstance } from "@sanity/sdk";
 
-import { useMemo, useRef, useEffect } from "react";
-
-import { useDocumentStore, useSource, useClient } from "sanity";
+import { ENGINE_API_VERSION, createEngine, EXECUTION_KINDS } from "@sanity/workflow-engine";
 
-import { useWorkflowTelemetry, useWorkflowSession as useWorkflowSession$1, useDocumentWorkflows as useDocumentWorkflows$1, useWorkflowInstances as useWorkflowInstances$1 } from "@sanity/workflow-react";
+import { useMemo, useEffect, useState } from "react";
 
-const RESUBSCRIBE_DELAY_MS = 5e3;
+import { useSource, useClient } from "sanity";
 
-function observableStore({observable: observable, resolve: resolve, initial: initial, name: name}) {
-    let latest = initial;
-    return {
-        subscribe(onChange) {
-            let subscription, retry, stopped = !1;
-            const connect = () => {
-                subscription = observable.subscribe({
-                    next: value => {
-                        latest = resolve(value), onChange();
-                    },
-                    error: err => {
-                        console.error(`[workflow-studio] ${name} stream errored — resubscribing in ${RESUBSCRIBE_DELAY_MS / 1e3}s:`, err), 
-                        stopped || (retry = setTimeout(connect, RESUBSCRIBE_DELAY_MS));
-                    }
-                });
-            };
-            return connect(), () => {
-                stopped = !0, retry !== void 0 && clearTimeout(retry), subscription?.unsubscribe();
-            };
-        },
-        getSnapshot: () => latest
-    };
-}
+import { useWorkflowTelemetry, useWorkflowSession as useWorkflowSession$1, useDocumentWorkflows as useDocumentWorkflows$1, useWorkflowInstances as useWorkflowInstances$1 } from "@sanity/workflow-react";
 
-function makeStudioObserver(documentStore, options) {
-    const {mounted: mounted, engineResource: engineResource, sdk: sdk, client: client} = options, engineIsMounted = sameDataset(engineResource, mounted), editStateStore = ({id: id, type: type, release: release, draftFallback: draftFallback}) => observableStore({
-        observable: documentStore.pair.editState(id, type, release),
-        resolve: editState => resolveEditState(editState, draftFallback),
-        initial: void 0,
-        name: `the edit state of "${id}"`
-    }), requireSdk = what => {
-        if (sdk !== void 0) return sdk;
-        throw new Error(`@sanity/workflow-studio: ${what} — Studio's document store is bound to ${mounted.projectId}.${mounted.dataset} and cannot observe it. Pass an App SDK instance via the hook's \`sdk\` option (e.g. \`useWorkflowSession({engine, instanceId, sdk})\`) to observe foreign resources.`);
-    };
+function makeStudioObserver(sdk, options) {
+    const {client: client, engineResource: engineResource} = options;
     return {
-        observeInstance: instanceId => engineIsMounted ? validatedInstanceStore(editStateStore({
-            id: instanceId,
-            type: WORKFLOW_INSTANCE_TYPE,
-            release: void 0,
-            draftFallback: !0
-        })) : validatedInstanceStore(sdkInstanceDocStore({
-            sdk: requireSdk(`instance "${instanceId}" lives in the engine dataset ${engineResource.projectId}.${engineResource.dataset}`),
-            instanceId: instanceId,
+        ...makeSdkObserver(sdk, {
             engineResource: engineResource
-        })),
-        observeDocs: (documents, perspective) => combineDocStores(documents.map(ref => classifyRef(ref, mounted) === "mounted-dataset" ? {
-            key: ref.globalDocumentId,
-            store: editStateStore({
-                id: ref.documentId,
-                type: ref.type,
-                release: contentReleaseName({
-                    ref: ref,
-                    perspective: perspective
-                }),
-                draftFallback: contentDraftFallback({
-                    ref: ref,
-                    perspective: perspective
-                })
-            })
-        } : {
-            key: ref.globalDocumentId,
-            store: sdkContentDocStore({
-                sdk: requireSdk(`"${ref.globalDocumentId}" lives outside this workspace`),
-                ref: ref,
-                perspective: perspective
-            })
-        })),
-        observeGuards: (instanceId, resources) => validatedGuardsStore(combineGuardStores(resources.map(resource => {
-            if (sameDataset(resource, mounted)) {
-                const {query: query, params: params} = instanceGuardQuery(instanceId);
-                return observableStore({
-                    observable: documentStore.listenQuery(query, params, {}),
-                    resolve: docs => docs,
-                    initial: void 0,
-                    name: `the guard list for "${instanceId}"`
-                });
-            }
-            return sdkGuardStore({
-                sdk: requireSdk(`guards for "${instanceId}" live in ${resource.projectId}.${resource.dataset}`),
-                instanceId: instanceId,
-                resource: resource
-            });
-        }))),
-        observeInstances: query => engineIsMounted ? validatedInstancesStore(observableStore({
-            observable: documentStore.listenQuery(query.query, query.params, {}),
-            resolve: docs => docs,
-            initial: void 0,
-            name: "the instance list"
-        })) : validatedInstancesStore(sdkInstancesStore({
-            sdk: requireSdk(`the instance list lives in the engine dataset ${engineResource.projectId}.${engineResource.dataset}`),
-            query: query,
-            resource: engineResource
-        })),
+        }),
         ensureDocumentExists: args => ensureDocumentExists(client, args)
     };
 }
 
-function resolveEditState(editState, draftFallback) {
-    if (!editState.ready) return;
-    const draft = draftFallback ? editState.draft : null;
-    return editState.version ?? draft ?? editState.published;
-}
-
 const SESSION_CLIENT_OPTIONS = {
     apiVersion: ENGINE_API_VERSION
 };
 
 function useStudioObserver({engine: engine, sdk: suppliedSdk}) {
-    const documentStore = useDocumentStore(), source = useSource(), {projectId: projectId, dataset: dataset} = source, mounted = useMemo(() => ({
+    const source = useSource(), {projectId: projectId, dataset: dataset} = source, mounted = useMemo(() => ({
         projectId: projectId,
         dataset: dataset
-    }), [ projectId, dataset ]), engineResource = useMemo(() => datasetResourceId(engine.workflowResource), [ engine ]), sdk = useEmbeddedSdk({
+    }), [ projectId, dataset ]), engineResource = useMemo(() => datasetResourceId(engine.workflowResource), [ engine ]), studio = useStudioAuth(), sdk = useEmbeddedSdk({
         supplied: suppliedSdk,
-        needed: !sameDataset(engineResource, mounted),
+        owner: source,
         mounted: mounted,
-        sessionToken: source.getClient(SESSION_CLIENT_OPTIONS).config().token
+        studio: studio
     });
-    return useMemo(() => makeStudioObserver(documentStore, {
-        mounted: mounted,
+    return useMemo(() => makeStudioObserver(sdk, {
         client: source.getClient(SESSION_CLIENT_OPTIONS),
-        engineResource: engineResource,
-        ...sdk !== void 0 ? {
-            sdk: sdk
-        } : {}
-    }), [ documentStore, source, mounted, engineResource, sdk ]);
+        engineResource: engineResource
+    }), [ source, engineResource, sdk ]);
 }
 
-function useEmbeddedSdk({supplied: supplied, needed: needed, mounted: mounted, sessionToken: sessionToken}) {
-    const wanted = supplied === void 0 && needed, held = useRef(void 0), key = `${mounted.projectId}.${mounted.dataset}`;
-    wanted && (held.current?.key !== key || held.current.instance.isDisposed()) && (held.current = {
+function useStudioAuth() {
+    const {authenticated: authenticated, auth: auth} = useSource();
+    return useMemo(() => {
+        const token = auth.token;
+        return token === void 0 ? {
+            authenticated: authenticated
+        } : {
+            authenticated: authenticated,
+            auth: {
+                token: token
+            }
+        };
+    }, [ authenticated, auth.token ]);
+}
+
+function useEmbeddedSdk({supplied: supplied, owner: owner, mounted: mounted, studio: studio}) {
+    const resolved = supplied === void 0 ? {
+        kind: "shared",
+        shared: sharedEmbeddedSdk({
+            owner: owner,
+            mounted: mounted,
+            studio: studio
+        })
+    } : {
+        kind: "supplied",
+        instance: supplied
+    };
+    return useSharedDispose(owner, resolved.kind === "shared" ? resolved.shared : void 0), 
+    resolved.kind === "shared" ? resolved.shared.instance : resolved.instance;
+}
+
+const sharedSdks = /* @__PURE__ */ new WeakMap;
+
+function sharedEmbeddedSdk({owner: owner, mounted: mounted, studio: studio}) {
+    const key = `${mounted.projectId}.${mounted.dataset}`;
+    let byResource = sharedSdks.get(owner);
+    byResource === void 0 && (byResource = /* @__PURE__ */ new Map, sharedSdks.set(owner, byResource));
+    const current = byResource.get(key);
+    if (current !== void 0 && !current.instance.isDisposed()) return current;
+    const shared = {
+        instance: bootstrapInstance(mounted, studio),
         key: key,
-        instance: bootstrapInstance(mounted, sessionToken)
-    });
-    const embedded = wanted ? held.current?.instance : void 0;
-    return useDeferredDispose(embedded), supplied ?? embedded;
+        users: 0
+    };
+    return byResource.set(key, shared), shared;
 }
 
-function bootstrapInstance(mounted, sessionToken) {
-    if (sessionToken === void 0) throw new Error("@sanity/workflow-studio: the engine's state dataset is not this workspace's dataset, and no Studio session token is readable to bootstrap an App SDK instance (cookie-authenticated studio?). Pass one explicitly via the hook's `sdk` option, e.g. useWorkflowSession({engine, instanceId, sdk}).");
+function bootstrapInstance(mounted, studio) {
     return createSanityInstance({
         projectId: mounted.projectId,
         dataset: mounted.dataset,
-        auth: {
-            token: sessionToken
-        }
+        studio: studio
     });
 }
 
-function useDeferredDispose(instance) {
-    const disposal = useRef(void 0);
+function useSharedDispose(owner, shared) {
     useEffect(() => {
-        if (instance !== void 0) return disposal.current?.instance === instance && (clearTimeout(disposal.current.timeoutId), 
-        disposal.current = void 0), () => {
-            disposal.current = {
-                instance: instance,
-                timeoutId: setTimeout(() => {
-                    instance.isDisposed() || instance.dispose();
-                }, 0)
-            };
+        if (shared !== void 0) return shared.users += 1, () => {
+            const byResource = sharedSdks.get(owner);
+            byResource?.get(shared.key) === shared && (shared.users -= 1, setTimeout(() => {
+                shared.users !== 0 || byResource.get(shared.key) !== shared || (shared.instance.isDisposed() || shared.instance.dispose(), 
+                byResource.delete(shared.key), byResource.size === 0 && sharedSdks.delete(owner));
+            }, 0));
         };
-    }, [ instance ]);
+    }, [ owner, shared ]);
 }
 
 function useWorkflowEngine({workflowResource: workflowResource, tag: tag, resourceClients: resourceClients, effectHandlers: effectHandlers, missingHandler: missingHandler}) {
@@ -258,4 +190,145 @@ function useDocumentWorkflows({engine: engine, document: document, sdk: sdk}) {
     });
 }
 
-export { makeStudioObserver, studioResourceClients, useDocumentWorkflows, useStudioObserver, useWorkflowEngine, useWorkflowInstances, useWorkflowSession };
+const PROJECT_USERS_TTL_MS = 3e4;
+
+function isRecord(value) {
+    return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+
+function isRole(value) {
+    return isRecord(value) && typeof value.name == "string";
+}
+
+function isMembership(value) {
+    return isRecord(value) && typeof value.id == "string" && (value.isRobot === void 0 || typeof value.isRobot == "boolean") && (value.roles === void 0 || Array.isArray(value.roles) && value.roles.every(isRole));
+}
+
+function isUser(value) {
+    return isRecord(value) && typeof value.id == "string" && (value.email === void 0 || typeof value.email == "string") && (value.displayName === void 0 || typeof value.displayName == "string") && (value.imageUrl === void 0 || value.imageUrl === null || typeof value.imageUrl == "string");
+}
+
+async function fetchProjectUsers(client, projectId) {
+    const project = await client.request({
+        uri: `/projects/${projectId}`
+    });
+    if (!isRecord(project) || !Array.isArray(project.members)) throw new Error("Studio project user response did not contain a members array");
+    const membershipRows = project.members;
+    if (!membershipRows.every(isMembership)) throw new Error("Studio project user response contained an invalid membership row");
+    const memberships = membershipRows.filter(member => !member.isRobot);
+    if (memberships.length === 0) return [];
+    const ids = memberships.map(member => encodeURIComponent(member.id)), response = await client.request({
+        uri: `/projects/${projectId}/users/${ids.join(",")}`
+    }), profiles = (Array.isArray(response) ? response : [ response ]).filter(isUser), profileById = new Map(profiles.map(profile => [ profile.id, profile ]));
+    return memberships.map(membership => ({
+        membership: membership,
+        profile: profileById.get(membership.id)
+    }));
+}
+
+const projectUsersByClient = /* @__PURE__ */ new WeakMap;
+
+function clientProjectUsers(client) {
+    const cached = projectUsersByClient.get(client);
+    if (cached) return cached;
+    const created = /* @__PURE__ */ new Map;
+    return projectUsersByClient.set(client, created), created;
+}
+
+function loadProjectUsers(client, projectId) {
+    const projectUsers = clientProjectUsers(client), cached = projectUsers.get(projectId);
+    if (cached && cached.expiresAt > Date.now()) return cached.promise;
+    projectUsers.delete(projectId);
+    const pending = fetchProjectUsers(client, projectId), entry = {
+        promise: pending,
+        expiresAt: Number.POSITIVE_INFINITY
+    };
+    return projectUsers.set(projectId, entry), pending.then(() => {
+        entry.expiresAt = Date.now() + PROJECT_USERS_TTL_MS;
+    }, () => {
+        projectUsers.get(projectId) === entry && projectUsers.delete(projectId);
+    }), pending;
+}
+
+function studioProjectUserDirectory(client, projectId) {
+    const load = () => loadProjectUsers(client, projectId);
+    return {
+        findById: async id => {
+            try {
+                const user = (await load()).find(candidate => candidate.membership.id === id);
+                return user ? {
+                    status: "resolved",
+                    user: user
+                } : {
+                    status: "missing"
+                };
+            } catch (cause) {
+                return {
+                    status: "inaccessible",
+                    cause: cause
+                };
+            }
+        },
+        findByEmail: async email => {
+            try {
+                const normalized = email.toLowerCase(), user = (await load()).find(candidate => candidate.profile?.email?.toLowerCase() === normalized);
+                return user ? {
+                    status: "resolved",
+                    user: user
+                } : {
+                    status: "missing"
+                };
+            } catch (cause) {
+                return {
+                    status: "inaccessible",
+                    cause: cause
+                };
+            }
+        }
+    };
+}
+
+function useStudioProjectUsers() {
+    const client = useClient({
+        apiVersion: ENGINE_API_VERSION
+    }), projectId = client.config().projectId, directory = useMemo(() => projectId ? studioProjectUserDirectory(client, projectId) : void 0, [ client, projectId ]), [state, setState] = useState({
+        users: [],
+        loading: projectId !== void 0,
+        error: projectId === void 0 ? new Error("No projectId on the Studio client") : void 0
+    });
+    return useEffect(() => {
+        if (!projectId) {
+            setState({
+                users: [],
+                loading: !1,
+                error: new Error("No projectId on the Studio client")
+            });
+            return;
+        }
+        let cancelled = !1;
+        return setState({
+            users: [],
+            loading: !0,
+            error: void 0
+        }), loadProjectUsers(client, projectId).then(users => {
+            cancelled || setState({
+                users: users,
+                loading: !1,
+                error: void 0
+            });
+        }, error => {
+            cancelled || setState({
+                users: [],
+                loading: !1,
+                error: error
+            });
+        }), () => {
+            cancelled = !0;
+        };
+    }, [ client, projectId ]), {
+        ...state,
+        directory: directory
+    };
+}
+
+export { makeStudioObserver, studioProjectUserDirectory, studioResourceClients, useDocumentWorkflows, useStudioObserver, useStudioProjectUsers, useWorkflowEngine, useWorkflowInstances, useWorkflowSession };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/workflow-studio",
-  "version": "0.8.0",
-  "description": "React adapter that drives the @sanity/workflow-engine reactive session from the Sanity Studio document store.",
+  "version": "0.9.0",
+  "description": "React adapter that drives the @sanity/workflow-engine reactive session in Sanity Studio through the App SDK store.",
   "keywords": [
     "sanity",
     "sanity-io",
@@ -41,9 +41,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@sanity/workflow-engine": "0.17.0",
-    "@sanity/workflow-react": "0.12.0",
-    "@sanity/workflow-sdk": "0.9.0"
+    "@sanity/workflow-engine": "0.18.0",
+    "@sanity/workflow-react": "0.13.0",
+    "@sanity/workflow-sdk": "0.10.0"
   },
   "devDependencies": {
     "@sanity/pkg-utils": "^10.5.2",
@@ -53,14 +53,13 @@
     "jsdom": "^29.1.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "sanity": "^5.30.0",
-    "vitest": "^4.1.8",
-    "@sanity/workflow-engine-test": "0.12.0"
+    "sanity": "^6",
+    "vitest": "^4.1.8"
   },
   "peerDependencies": {
     "@sanity/sdk": "^2.12.0",
     "react": "^19.2.7",
-    "sanity": "^5.30.0"
+    "sanity": "^6"
   },
   "engines": {
     "node": ">=20"