@gooddata/sdk-ui-ext 11.43.0-alpha.0 → 11.43.0-alpha.2

package/esm/share/useObjectShareController.js

@@ -0,0 +1,347 @@
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo, useState } from "react";
+import { useToastMessage } from "@gooddata/sdk-ui-kit";
+import { objectShareMessages } from "./messages.js";
+import { EMPTY_IDS, NO_LABELS, granularGranteeFor, toGranularGrantee, } from "./objectShareController.helpers.js";
+import { useAccessList } from "./useAccessList.js";
+import { useLabelScope } from "./useLabelScope.js";
+/**
+ * Manages the share dialog state and backend I/O for a single shareable
+ * object.
+ *
+ * The access list is fetched (and re-fetched after every save) via
+ * `useCancelablePromise`; everything that reflects the backend — the grantee
+ * rows, general-access value, summary — is derived from it on render, never
+ * copied into local state. Local state is only the dialog's own transient UI:
+ * the active subview, the add-grantee buffer, the pending general-access
+ * confirm, and an in-flight save flag. Top-level open/close is the consumer's
+ * concern (see {@link ObjectShareDialog}).
+ *
+ * Mutations follow a **commit-on-interaction** model: each access change is
+ * sent immediately; the general-access toggle goes through a confirm step
+ * because it is high-impact. There is no batched Save. The list is fetched
+ * eagerly so `state.summary` also drives an inline access row while closed.
+ *
+ * @internal
+ */
+export function useObjectShareController(target, onSaved, labels = NO_LABELS, labelsError = false, labelsLoading = false) {
+    const toast = useToastMessage();
+    // UI-local buffers — never backend data.
+    const [subview, setSubview] = useState("main");
+    const [pendingGrantees, setPendingGrantees] = useState([]);
+    const [pendingGeneralAccess, setPendingGeneralAccess] = useState(undefined);
+    // The backend access list + optimistic overlay (rows, general access, summary,
+    // the commit/picker primitives) live in their own hook.
+    const { targetKey, currentAccessList, grantees, granteeIdsKey, generalAccess, summary, status, loadError, commit, loadOptions, refForId, setOverlay, setKnownNames, setOptimisticGeneralAccess, } = useAccessList(target, onSaved);
+    // Per-label scope resolution + the single label-write path live in their own hook.
+    const { effectiveLabels, labelsResolved, selectedLabelIdsByGrantee, setSelectedLabelIdsByGrantee, optimisticScopeRef, reconcileLabelScope, } = useLabelScope(target, targetKey, labels, currentAccessList, granteeIdsKey, labelsError, labelsLoading);
+    // Drop the transient UI buffers when the permission target changes. The detail
+    // view is reused across objects and closes the dialog by toggling `isOpen`
+    // alone, so without this a staged add-grantee subview or general-access confirm
+    // would survive navigation and reappear on (and apply to) the next object.
+    // Reset during render — React's "adjust state on prop change" idiom — rather
+    // than in an effect, so the stale buffers never reach a commit.
+    const [lastTargetKey, setLastTargetKey] = useState(targetKey);
+    if (lastTargetKey !== targetKey) {
+        setLastTargetKey(targetKey);
+        setSubview("main");
+        setPendingGrantees([]);
+        setPendingGeneralAccess(undefined);
+    }
+    const reset = useCallback(() => {
+        setSubview("main");
+        setPendingGrantees([]);
+        setPendingGeneralAccess(undefined);
+    }, []);
+    const openAddGrantee = useCallback(() => {
+        setSubview("addGrantee");
+        setPendingGrantees([]);
+    }, []);
+    const closeAddGrantee = useCallback(() => {
+        setSubview("main");
+        setPendingGrantees([]);
+    }, []);
+    const confirmAddGrantees = useCallback(async () => {
+        if (pendingGrantees.length === 0) {
+            return;
+        }
+        // Optimistically insert the picked grantees as pending rows, carrying the
+        // picker's display name so the new row never renders a raw id.
+        const added = pendingGrantees.map((g) => ({
+            id: g.id,
+            grantee: {
+                id: g.id,
+                kind: g.kind,
+                granteeRef: refForId(g.id),
+                name: g.name,
+                level: g.permissionLevel,
+            },
+        }));
+        const mutations = pendingGrantees.map((g) => toGranularGrantee(g.kind, refForId(g.id), g.permissionLevel));
+        setOverlay((prev) => {
+            const next = { ...prev };
+            for (const { id, grantee } of added) {
+                next[id] = { op: "set", grantee, pending: true };
+            }
+            return next;
+        });
+        // Cache the picked names so the rows keep them after the overlay reconciles.
+        setKnownNames((prev) => {
+            const next = { ...prev };
+            for (const { id, grantee } of added) {
+                next[id] = grantee.name;
+            }
+            return next;
+        });
+        // Leave the add subview at once so the new rows show in the main list.
+        closeAddGrantee();
+        const ok = await commit(mutations, objectShareMessages.toastGranteeAdded);
+        if (!ok) {
+            // Roll back the failed adds; refresh() already reconciled on success.
+            setOverlay((prev) => {
+                const next = { ...prev };
+                for (const { id } of added) {
+                    delete next[id];
+                }
+                return next;
+            });
+            return;
+        }
+        // Default each new grantee to ALL labels (the picker's Add is gated until
+        // labels have loaded, so the set is known here). Reflect the full scope
+        // optimistically and hold it through read-after-write lag; if any label
+        // write fails, surface it and drop that grantee's optimistic scope rather
+        // than claim access that didn't persist.
+        const allLabelIds = effectiveLabels.map((l) => l.id);
+        const allLabelIdSet = new Set(allLabelIds);
+        for (const g of pendingGrantees) {
+            optimisticScopeRef.current.add(g.id);
+        }
+        setSelectedLabelIdsByGrantee((prev) => {
+            const next = { ...prev };
+            for (const g of pendingGrantees) {
+                next[g.id] = allLabelIds;
+            }
+            return next;
+        });
+        const scoped = await Promise.all(pendingGrantees.map((g) => reconcileLabelScope({ kind: g.kind, granteeRef: refForId(g.id) }, allLabelIdSet, EMPTY_IDS)));
+        const failed = pendingGrantees.filter((_, i) => !scoped[i]);
+        if (failed.length > 0) {
+            toast.addWarning(objectShareMessages.toastLabelScopePartial);
+            // Some non-primary label writes didn't persist. Don't drop the entry —
+            // a missing entry means "all selected", which would falsely show full
+            // access. Pin the failed grantees to the primary label only (the one
+            // that's always granted with the object), reflecting what actually stuck.
+            const primaryIds = effectiveLabels.filter((l) => l.isPrimary).map((l) => l.id);
+            setSelectedLabelIdsByGrantee((prev) => {
+                const next = { ...prev };
+                for (const g of failed) {
+                    next[g.id] = primaryIds;
+                }
+                return next;
+            });
+        }
+    }, [
+        pendingGrantees,
+        commit,
+        closeAddGrantee,
+        effectiveLabels,
+        reconcileLabelScope,
+        refForId,
+        toast,
+        setOverlay,
+        setKnownNames,
+        setSelectedLabelIdsByGrantee,
+        optimisticScopeRef,
+    ]);
+    const changePermissionLevel = useCallback(async (granteeId, level) => {
+        const grantee = grantees.find((g) => g.id === granteeId);
+        if (!grantee || grantee.level === level || grantee.pending) {
+            return;
+        }
+        const previousLevel = grantee.level;
+        // Show the new level immediately; keep it through the backend's
+        // read-after-write lag (reconcileOverlay clears it once confirmed).
+        setOverlay((prev) => ({
+            ...prev,
+            [granteeId]: { op: "set", grantee: { ...grantee, level }, pending: true },
+        }));
+        const ok = await commit([toGranularGrantee(grantee.kind, grantee.granteeRef, level)], objectShareMessages.toastAccessUpdated);
+        if (!ok) {
+            // Revert to the prior level on failure.
+            setOverlay((prev) => ({
+                ...prev,
+                [granteeId]: { op: "set", grantee: { ...grantee, level: previousLevel }, pending: false },
+            }));
+        }
+    }, [grantees, commit, setOverlay]);
+    const removeGrantee = useCallback(async (granteeId) => {
+        const grantee = grantees.find((g) => g.id === granteeId);
+        if (!grantee || grantee.pending) {
+            return;
+        }
+        // Mark the row removed but keep it visible (muted) until the write lands.
+        setOverlay((prev) => ({ ...prev, [granteeId]: { op: "remove", pending: true } }));
+        // Revoke the grantee's per-label grants too — they are independent
+        // access-list entries, so the object revoke alone would leave them
+        // behind. Reconcile to an empty scope (current = all permissionable).
+        const allCurrent = new Set(effectiveLabels.map((l) => l.id));
+        const principal = { kind: grantee.kind, granteeRef: grantee.granteeRef };
+        const labelsRevoked = await reconcileLabelScope(principal, EMPTY_IDS, allCurrent);
+        const ok = await commit([toGranularGrantee(grantee.kind, grantee.granteeRef, "none")], objectShareMessages.toastAccessUpdated);
+        if (!ok) {
+            // Restore the row on failure — and re-grant the labels we just
+            // revoked, so a failed object revoke doesn't strip label access
+            // while the grantee row stays.
+            if (labelsRevoked) {
+                await reconcileLabelScope(principal, allCurrent, EMPTY_IDS);
+            }
+            setOverlay((prev) => {
+                const { [granteeId]: _omit, ...rest } = prev;
+                return rest;
+            });
+        }
+        else if (!labelsRevoked) {
+            // Object access is gone but some per-label grants couldn't be
+            // revoked — warn so the leftover scope isn't mistaken for success.
+            toast.addWarning(objectShareMessages.toastLabelScopePartial);
+        }
+    }, [grantees, commit, effectiveLabels, reconcileLabelScope, toast, setOverlay]);
+    const changeGranteeLabels = useCallback(async (granteeId, requested) => {
+        const grantee = grantees.find((g) => g.id === granteeId);
+        if (!grantee || !target) {
+            return;
+        }
+        // Primary label is always in scope; never let it be dropped.
+        const primaryIds = effectiveLabels.filter((l) => l.isPrimary).map((l) => l.id);
+        const nextScope = Array.from(new Set([...requested, ...primaryIds]));
+        const currentScope = selectedLabelIdsByGrantee[granteeId] ?? effectiveLabels.map((l) => l.id);
+        const desired = new Set(nextScope);
+        const current = new Set(currentScope);
+        // Optimistic: reflect the new scope immediately and hold it through lag.
+        const previousScope = currentScope;
+        optimisticScopeRef.current.add(granteeId);
+        setSelectedLabelIdsByGrantee((prev) => ({ ...prev, [granteeId]: nextScope }));
+        const ok = await reconcileLabelScope({ kind: grantee.kind, granteeRef: grantee.granteeRef }, desired, current);
+        if (ok) {
+            toast.addSuccess(objectShareMessages.toastAccessUpdated);
+            onSaved?.();
+            // Keep the optimistic scope as the source of truth — re-resolving now
+            // would clobber it with the backend's read-after-write-stale value
+            // (same lag the grantee overlay handles).
+        }
+        else {
+            toast.addError(objectShareMessages.toastError);
+            setSelectedLabelIdsByGrantee((prev) => ({ ...prev, [granteeId]: previousScope }));
+        }
+    }, [
+        grantees,
+        target,
+        effectiveLabels,
+        selectedLabelIdsByGrantee,
+        reconcileLabelScope,
+        toast,
+        onSaved,
+        setSelectedLabelIdsByGrantee,
+        optimisticScopeRef,
+    ]);
+    const requestGeneralAccessChange = useCallback((next) => {
+        if (next !== generalAccess) {
+            setPendingGeneralAccess(next);
+        }
+    }, [generalAccess]);
+    const confirmGeneralAccessChange = useCallback(async () => {
+        const next = pendingGeneralAccess;
+        if (!next || next === generalAccess) {
+            setPendingGeneralAccess(undefined);
+            return;
+        }
+        const previous = generalAccess;
+        // Apply optimistically and close the confirm at once — the radio + summary
+        // reflect `next` immediately; the write commits in the background.
+        setOptimisticGeneralAccess(next);
+        setPendingGeneralAccess(undefined);
+        const principal = { allWorkspaceUsers: true };
+        const allIds = new Set(effectiveLabels.map((l) => l.id));
+        // The workspace rule must cover every label too, or the workspace would
+        // hold object access while non-primary labels stay ungranted. Mirror it
+        // first (WORKSPACE → all labels, RESTRICTED → none), then write the object.
+        const [desired, current] = next === "WORKSPACE" ? [allIds, EMPTY_IDS] : [EMPTY_IDS, allIds];
+        const mirrored = await reconcileLabelScope(principal, desired, current);
+        if (!mirrored) {
+            // The label mirror failed: don't write the object grant on top of a
+            // half-applied label scope. Undo whatever mirrored, revert the
+            // optimistic override and surface the error.
+            await reconcileLabelScope(principal, current, desired);
+            setOptimisticGeneralAccess((value) => (value === next ? previous : value));
+            toast.addError(objectShareMessages.toastError);
+            return;
+        }
+        const ok = await commit([granularGranteeFor(principal, next === "WORKSPACE" ? "VIEW" : "none")], objectShareMessages.toastGeneralAccessUpdated);
+        if (!ok) {
+            // Object write failed: undo the label mirror too, so labels and object
+            // don't drift, and revert the optimistic override.
+            await reconcileLabelScope(principal, current, desired);
+            setOptimisticGeneralAccess((value) => (value === next ? previous : value));
+        }
+    }, [
+        pendingGeneralAccess,
+        generalAccess,
+        commit,
+        effectiveLabels,
+        reconcileLabelScope,
+        toast,
+        setOptimisticGeneralAccess,
+    ]);
+    const actions = useMemo(() => ({
+        reset,
+        openAddGrantee,
+        closeAddGrantee,
+        setPendingGrantees,
+        loadOptions,
+        confirmAddGrantees,
+        changePermissionLevel,
+        removeGrantee,
+        changeGranteeLabels,
+        requestGeneralAccessChange,
+        cancelGeneralAccessChange: () => setPendingGeneralAccess(undefined),
+        confirmGeneralAccessChange,
+    }), [
+        reset,
+        openAddGrantee,
+        closeAddGrantee,
+        loadOptions,
+        confirmAddGrantees,
+        changePermissionLevel,
+        removeGrantee,
+        changeGranteeLabels,
+        requestGeneralAccessChange,
+        confirmGeneralAccessChange,
+    ]);
+    const state = useMemo(() => ({
+        subview,
+        status,
+        error: loadError,
+        summary,
+        grantees,
+        generalAccess,
+        labels: effectiveLabels,
+        labelsResolved,
+        selectedLabelIdsByGrantee,
+        pendingGeneralAccess,
+        pendingGrantees,
+    }), [
+        subview,
+        status,
+        loadError,
+        summary,
+        grantees,
+        generalAccess,
+        effectiveLabels,
+        labelsResolved,
+        selectedLabelIdsByGrantee,
+        pendingGeneralAccess,
+        pendingGrantees,
+    ]);
+    return useMemo(() => ({ state, actions }), [state, actions]);
+}

package/esm/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.7"
+      "packageVersion": "7.58.9"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-ext",
-  "version": "11.43.0-alpha.0",
+  "version": "11.43.0-alpha.2",
   "description": "GoodData.UI SDK - Extensions",
   "license": "LicenseRef-LICENSE",
   "author": "GoodData Corporation",
@@ -64,20 +64,20 @@
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
     "uuid": "11.1.1",
-    "@gooddata/sdk-backend-base": "11.43.0-alpha.0",
-    "@gooddata/sdk-embedding": "11.43.0-alpha.0",
-    "@gooddata/sdk-backend-spi": "11.43.0-alpha.0",
-    "@gooddata/sdk-model": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-charts": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-filters": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-geo": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-pivot": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-kit": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-semantic-search": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-vis-commons": "11.43.0-alpha.0",
-    "@gooddata/sdk-ui-theme-provider": "11.43.0-alpha.0",
-    "@gooddata/util": "11.43.0-alpha.0"
+    "@gooddata/sdk-backend-base": "11.43.0-alpha.2",
+    "@gooddata/sdk-backend-spi": "11.43.0-alpha.2",
+    "@gooddata/sdk-embedding": "11.43.0-alpha.2",
+    "@gooddata/sdk-model": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-charts": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-filters": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-geo": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-kit": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-semantic-search": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-theme-provider": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-pivot": "11.43.0-alpha.2",
+    "@gooddata/sdk-ui-vis-commons": "11.43.0-alpha.2",
+    "@gooddata/util": "11.43.0-alpha.2"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -125,12 +125,12 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.43.0-alpha.0",
-    "@gooddata/sdk-backend-mockingbird": "11.43.0-alpha.0",
-    "@gooddata/i18n-toolkit": "11.43.0-alpha.0",
-    "@gooddata/reference-workspace": "11.43.0-alpha.0",
-    "@gooddata/stylelint-config": "11.43.0-alpha.0",
-    "@gooddata/oxlint-config": "11.43.0-alpha.0"
+    "@gooddata/eslint-config": "11.43.0-alpha.2",
+    "@gooddata/i18n-toolkit": "11.43.0-alpha.2",
+    "@gooddata/reference-workspace": "11.43.0-alpha.2",
+    "@gooddata/oxlint-config": "11.43.0-alpha.2",
+    "@gooddata/sdk-backend-mockingbird": "11.43.0-alpha.2",
+    "@gooddata/stylelint-config": "11.43.0-alpha.2"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",