@gooddata/sdk-ui-ext 11.52.0-alpha.6 → 11.52.0-alpha.7

package/esm/share/useAccessList.js

@@ -5,7 +5,7 @@ import { convertError, useBackendStrict, useCancelablePromise, useWorkspaceStric
 import { useToastMessage } from "@gooddata/sdk-ui-kit";
 import { composeEffectiveWorkspaceAccess, deriveGeneralAccess, deriveInheritedWorkspaceLevel, deriveWorkspacePermissionLevel, } from "./accessSummary.js";
 import { objectShareMessages } from "./messages.js";
-import { assigneeIdentityFacts, assigneeMatchesQuery, effectivePermissionAbove, granteeId, granteesFromAccessList, mergeGrantees, userDisplayPair, userIdentityFacts, } from "./objectShareController.helpers.js";
+import { assigneeIdentityFacts, assigneeMatchesQuery, granteeId, granteesFromAccessList, mergeGrantees, userDisplayPair, userIdentityFacts, withDirectLevel, } from "./objectShareController.helpers.js";
 /**
  * Owns the backend access list for ONE dialog session: the hook is mounted while
  * the dialog is open, for a single target that must not change while mounted
@@ -167,16 +167,25 @@ export function useAccessList(target) {
             const settled = current ? { ...current, settled: undefined } : undefined;
             if (current?.kind === "added") {
                 // Overlay-born row: stay an `added` entry, or the merge would drop it.
-                const grantee = {
-                    ...current.grantee,
-                    level,
-                    effectivePermission: effectivePermissionAbove(level, current.grantee.inheritedLevel),
-                };
+                const grantee = withDirectLevel(current.grantee, level);
                 return { ...prev, [id]: { kind: "added", grantee, pending: true, settled } };
             }
             return { ...prev, [id]: { kind: "level", level, pending: true, settled } };
         });
     }, []);
+    // Lock a row for a write that does NOT change its access (a label-scope edit). The
+    // lock WRAPS whatever the row committed rather than modifying it: reusing the
+    // existing entry and flipping `pending` would re-arm it, and `pending` means
+    // something different per kind — a settled removal would read as a revoke in flight
+    // and render the row as removing at its pre-removal level. Both settling and failing
+    // unwrap back to the entry underneath, because a label write changes neither.
+    const applyGranteeLock = useCallback((id) => {
+        setGranteeEdits((prev) => {
+            const current = prev[id];
+            const settled = current ? { ...current, settled: undefined } : undefined;
+            return { ...prev, [id]: { kind: "locked", pending: true, settled } };
+        });
+    }, []);
     const applyGranteeRemove = useCallback((id) => {
         setGranteeEdits((prev) => {
             const current = prev[id];
@@ -190,6 +199,16 @@ export function useAccessList(target) {
             if (!current) {
                 return prev;
             }
+            // A lock is a wrapper over the row's committed state, so settling it unwraps —
+            // same as failing. Keeping a settled `locked` entry would discard the entry it
+            // wrapped and drop the row back to its fetched state.
+            if (current.kind === "locked") {
+                if (!current.settled) {
+                    const { [id]: _omit, ...rest } = prev;
+                    return rest;
+                }
+                return { ...prev, [id]: current.settled };
+            }
             // A settled removal always keeps its entry: for a base row (including a
             // removed re-added one) it is what keeps the row hidden; for an
             // overlay-born row it renders nothing and is harmless.
@@ -238,6 +257,7 @@ export function useAccessList(target) {
         loadOptions,
         applyGranteeAdd,
         applyGranteeLevel,
+        applyGranteeLock,
         applyGranteeRemove,
         settleGranteeEdit,
         failGranteeEdit,

package/esm/share/useLabelScope.d.ts

@@ -1,5 +1,5 @@
 import type { IObjectPermissionsObject } from "@gooddata/sdk-backend-spi";
-import { type LabelScopePrincipal } from "./objectShareController.helpers.js";
+import { type ILabelScopeChange, type LabelScopePrincipal } from "./objectShareController.helpers.js";
 import type { IObjectShareLabel } from "./types.js";
 /**
  * Per-label access scope for the share dialog: which labels each grantee can
@@ -38,6 +38,30 @@ export interface ILabelScope {
     /** Per-grantee label scope: grantee id → label ids in scope (primary always in). */
     selectedLabelIdsByGrantee: Record<string, string[]>;
     setSelectedLabelIdsByGrantee: React.Dispatch<React.SetStateAction<Record<string, string[]>>>;
+    /**
+     * In-scope labels whose access the grantee INHERITS, per grantee id — including ones
+     * they also hold a local grant on. Callers render these locked: unchecking cannot take
+     * the access away. Derived straight from the probe, never optimistic, because only the
+     * backend can say where a grant lives.
+     */
+    inheritedLabelIdsByGrantee: Record<string, string[]>;
+    /**
+     * Labels THIS workspace grants the grantee, per grantee id — the only ones a write may
+     * target, and the complement of "inherited only". An optimistic overlay, not a
+     * derivation: the per-label probe runs once per session, so after the dialog revokes or
+     * grants a label the probe's answer is stale and acting on it re-creates access that was
+     * just removed. Every label write reports its outcome through
+     * {@link recordDirectLabelWrites}.
+     */
+    directLabelIdsByGrantee: Record<string, string[]>;
+    /**
+     * Record the outcome of the dialog's OWN label writes so the direct set stays true:
+     * `granted` ids gain a local grant, `revoked` ids lose theirs. Pass only the writes
+     * that actually landed.
+     */
+    recordDirectLabelWrites: (granteeId: string, granted: readonly string[], revoked: readonly string[]) => void;
+    /** Forget a grantee's label bookkeeping once their row is gone for good. */
+    forgetGranteeLabels: (granteeId: string) => void;
     /**
      * The single per-label write path. Diffs `desired` vs `current` over the
      * permissionable labels and issues one `manageObjectPermissions` per changed
@@ -49,6 +73,27 @@ export interface ILabelScope {
         ok: boolean;
         failedLabelIds: string[];
     }>;
+    /**
+     * Per-principal variant of {@link reconcileLabelScope}: each principal moves its
+     * OWN scope, for grantees added in one step that each picked a different label
+     * scope. Still one write per label carrying every principal that changes on it,
+     * so a shared label costs one call regardless of how the scopes differ.
+     */
+    reconcileLabelScopes: (changes: ILabelScopeChange[]) => Promise<{
+        ok: boolean;
+        failedLabelIds: string[];
+    }>;
+    /**
+     * Re-grades an UNCHANGED label scope to each principal's `level` — what a
+     * permission-level change on the object needs so its labels don't keep the level
+     * they were granted at. Not a diff: every in-scope label is rewritten (a diff
+     * over an unchanged set produces no writes). Same independent settling and
+     * `failedLabelIds` reporting as {@link reconcileLabelScope}.
+     */
+    regradeLabelScope: (principals: LabelScopePrincipal[], scopeLabelIds: ReadonlySet<string>) => Promise<{
+        ok: boolean;
+        failedLabelIds: string[];
+    }>;
 }
 /**
  * Owns label-scope resolution + writes for {@link useObjectShareController}.

package/esm/share/useLabelScope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLabelScope.d.ts","sourceRoot":"","sources":["../../src/share/useLabelScope.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAK1E,OAAO,EACH,KAAK,mBAAmB,EAG3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA6BpD;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB;;;;OAIG;IACH,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC;;;;;;;;OAQG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;;;;;OAQG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B,sFAAoF;IACpF,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,4BAA4B,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7F;;;;;;OAMG;IACH,mBAAmB,EAAE,CACjB,UAAU,EAAE,mBAAmB,EAAE,EACjC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,EACpC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,KACnC,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,MAAM,EAAE,iBAAiB,EAAE,EAC3B,OAAO,EAAE,OAAO,EAChB,mBAAmB,EAAE,MAAM,EAAE,EAC7B,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,OAAO,GACvB,WAAW,CAmKb"}
+{"version":3,"file":"useLabelScope.d.ts","sourceRoot":"","sources":["../../src/share/useLabelScope.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAK1E,OAAO,EACH,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EAI3B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA6EpD;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB;;;;OAIG;IACH,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC;;;;;;;;OAQG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;;;;;OAQG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAC5B,sFAAoF;IACpF,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpD,4BAA4B,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAC7F;;;;;OAKG;IACH,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACrD;;;;;;;OAOG;IACH,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAClD;;;;OAIG;IACH,uBAAuB,EAAE,CACrB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,EAAE,SAAS,MAAM,EAAE,KACzB,IAAI,CAAC;IACV,4EAA4E;IAC5E,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD;;;;;;OAMG;IACH,mBAAmB,EAAE,CACjB,UAAU,EAAE,mBAAmB,EAAE,EACjC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,EACpC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,KACnC,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACxD;;;;;OAKG;IACH,oBAAoB,EAAE,CAClB,OAAO,EAAE,iBAAiB,EAAE,KAC3B,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IACxD;;;;;;OAMG;IACH,iBAAiB,EAAE,CACf,UAAU,EAAE,mBAAmB,EAAE,EACjC,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,KACjC,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CAC3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CACzB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,MAAM,EAAE,iBAAiB,EAAE,EAC3B,OAAO,EAAE,OAAO,EAChB,mBAAmB,EAAE,MAAM,EAAE,EAC7B,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,OAAO,GACvB,WAAW,CA6Ob"}

package/esm/share/useLabelScope.js

@@ -2,8 +2,13 @@
 import { useCallback, useMemo, useState } from "react";
 import { useBackendStrict, useCancelablePromise, useWorkspaceStrict } from "@gooddata/sdk-ui";
 import { isPermissionsNotAvailable } from "./accessErrors.js";
-import { buildLabelMutationsForPrincipals, isGranteeGrantedIn, } from "./objectShareController.helpers.js";
-/** Pure: each grantee's in-scope label ids — primary always counts, others only where the grantee is granted. */
+import { buildLabelMutationsForScopes, buildLabelRegrades, granteeGrantIn, } from "./objectShareController.helpers.js";
+/**
+ * Pure: each grantee's in-scope label ids — primary always counts, others wherever
+ * the grantee holds the label, whether granted here or inherited. An inherited label
+ * is genuinely in scope: the grantee can read it, so the checklist must show it
+ * checked, exactly as the parent workspace shows it.
+ */
 function resolveScopes(results, committedGranteeIds) {
     const resolved = {};
     for (const id of committedGranteeIds) {
@@ -14,13 +19,52 @@ function resolveScopes(results, committedGranteeIds) {
             continue;
         }
         for (const id of committedGranteeIds) {
-            if (result.label.isPrimary || isGranteeGrantedIn(result.list, id)) {
+            if (result.label.isPrimary || granteeGrantIn(result.list, id)) {
                 resolved[id].push(result.label.id);
             }
         }
     }
     return resolved;
 }
+/**
+ * Pure: per-grantee label provenance, split by which question it answers. A label that is
+ * both granted here and inherited appears in BOTH maps, and that is the point — the two
+ * facts drive different decisions.
+ *
+ * - `inherited` — access survives revoking whatever this workspace granted, so the
+ *   checkbox stays checked and locked. Immutable for the session: no write from this
+ *   workspace can change a group's or a parent's grant, so deriving it from the probe
+ *   cannot go stale.
+ * - `direct` — granted HERE, so it is the only thing a write may target. This one DOES
+ *   change under our own writes, so the hook keeps it as an optimistic overlay seeded from
+ *   here rather than re-deriving it from a probe that runs once per session.
+ *
+ * The primary label is excluded from both: it is locked for every grantee regardless, and
+ * never written.
+ */
+function resolveLabelProvenance(results, committedGranteeIds) {
+    const inherited = {};
+    const direct = {};
+    for (const id of committedGranteeIds) {
+        inherited[id] = [];
+        direct[id] = [];
+    }
+    for (const result of results) {
+        if ("transient" in result || result.label.isPrimary) {
+            continue;
+        }
+        for (const id of committedGranteeIds) {
+            const grant = granteeGrantIn(result.list, id);
+            if (grant?.inherited) {
+                inherited[id].push(result.label.id);
+            }
+            if (grant?.direct) {
+                direct[id].push(result.label.id);
+            }
+        }
+    }
+    return { inherited, direct };
+}
 /**
  * Owns label-scope resolution + writes for {@link useObjectShareController}.
  * Resolves each grantee's scope by fetching every label's access list, tracks
@@ -41,6 +85,10 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
     // a fresh add / labels edit must survive the backend's lagging re-read, so the
     // probe below only seeds grantees it doesn't already know.
     const [selectedLabelIdsByGrantee, setSelectedLabelIdsByGrantee] = useState({});
+    // Which labels THIS workspace grants each grantee. Optimistic for the same reason the
+    // scope is, and for a sharper one: our own revokes and grants change it, and the probe
+    // will not run again to notice.
+    const [directLabelIdsByGrantee, setDirectLabelIdsByGrantee] = useState({});
     // Whether the session's first probe has settled (see `labelsInitializing`) —
     // a fact about session history, so it is state, flipped once in onSuccess.
     const [everResolved, setEverResolved] = useState(false);
@@ -52,6 +100,7 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
     if (seenLabelsKey !== labelsKey) {
         setSeenLabelsKey(labelsKey);
         setSelectedLabelIdsByGrantee({});
+        setDirectLabelIdsByGrantee({});
     }
     // Probe each label's access list to learn which are permissionable (some 404) and
     // which each grantee holds. `hasList` gates it: a list with no named grantees keeps
@@ -73,6 +122,7 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
         onSuccess: (results) => {
             setEverResolved(true);
             const resolved = resolveScopes(results, committedGranteeIds);
+            const { direct } = resolveLabelProvenance(results, committedGranteeIds);
             // Seed only grantees we don't already have a scope for — an optimistic
             // scope is authoritative and must survive this re-resolution. Fired once
             // per resolution (onSuccess), so reading `prev` is safe.
@@ -83,6 +133,14 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
                 }
                 return next;
             });
+            // Same rule for the direct set: what we wrote outranks what the probe read.
+            setDirectLabelIdsByGrantee((prev) => {
+                const next = {};
+                for (const id of committedGranteeIds) {
+                    next[id] = prev[id] ?? direct[id];
+                }
+                return next;
+            });
         },
     }, 
     // Keyed on the label set's stable string hash, not the array (rebuilt every
@@ -112,6 +170,30 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
         }
         return permissionable;
     }, [labelLists]);
+    // Inheritance is the one fact no write from here can change, so it stays a pure
+    // derivation of the probe — there is no optimistic version of "someone else granted
+    // this", and nothing we do can make it stale.
+    const inheritedLabelIdsByGrantee = useMemo(() => (labelLists ? resolveLabelProvenance(labelLists, committedGranteeIds).inherited : {}), [labelLists, committedGranteeIds]);
+    const recordDirectLabelWrites = useCallback((granteeId, granted, revoked) => {
+        if (granted.length === 0 && revoked.length === 0) {
+            return;
+        }
+        setDirectLabelIdsByGrantee((prev) => {
+            const dropped = new Set(revoked);
+            const kept = (prev[granteeId] ?? []).filter((id) => !dropped.has(id));
+            return { ...prev, [granteeId]: Array.from(new Set([...kept, ...granted])) };
+        });
+    }, []);
+    const forgetGranteeLabels = useCallback((granteeId) => {
+        setSelectedLabelIdsByGrantee((prev) => {
+            const { [granteeId]: _scope, ...rest } = prev;
+            return rest;
+        });
+        setDirectLabelIdsByGrantee((prev) => {
+            const { [granteeId]: _direct, ...rest } = prev;
+            return rest;
+        });
+    }, []);
     // Only permissionable labels are scope-controllable; assume all until resolved.
     const effectiveLabels = useMemo(() => hasList && permissionableLabelIds
         ? labels.filter((l) => permissionableLabelIds.has(l.id))
@@ -137,8 +219,9 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
     // drift. Writes settle independently (allSettled), and the failed labels are
     // reported by id — never collapsed into one boolean, or a partial failure would
     // roll callers back past writes that actually landed.
-    const reconcileLabelScope = useCallback(async (principals, desiredLabelIds, currentLabelIds) => {
-        const writes = buildLabelMutationsForPrincipals(principals, desiredLabelIds, currentLabelIds, effectiveLabels);
+    // Issues one manageObjectPermissions per label and reports the failures by id.
+    // Shared by the scope diff and the level re-grade so both settle identically.
+    const writeLabels = useCallback(async (writes) => {
         if (writes.length === 0) {
             return { ok: true, failedLabelIds: [] };
         }
@@ -148,13 +231,22 @@ export function useLabelScope(target, labels, hasList, committedGranteeIds, labe
             .filter((_, i) => results[i].status === "rejected")
             .map((w) => w.id);
         return { ok: failedLabelIds.length === 0, failedLabelIds };
-    }, [effectiveLabels, backend, workspace]);
+    }, [backend, workspace]);
+    const reconcileLabelScopes = useCallback((changes) => writeLabels(buildLabelMutationsForScopes(changes, effectiveLabels)), [effectiveLabels, writeLabels]);
+    const reconcileLabelScope = useCallback((principals, desiredLabelIds, currentLabelIds) => reconcileLabelScopes(principals.map((principal) => ({ principal, desiredLabelIds, currentLabelIds }))), [reconcileLabelScopes]);
+    const regradeLabelScope = useCallback((principals, scopeLabelIds) => writeLabels(buildLabelRegrades(principals, scopeLabelIds, effectiveLabels)), [effectiveLabels, writeLabels]);
     return {
         effectiveLabels,
         labelsResolved,
         labelsInitializing,
         selectedLabelIdsByGrantee,
         setSelectedLabelIdsByGrantee,
+        inheritedLabelIdsByGrantee,
+        directLabelIdsByGrantee,
+        recordDirectLabelWrites,
+        forgetGranteeLabels,
         reconcileLabelScope,
+        reconcileLabelScopes,
+        regradeLabelScope,
     };
 }

package/esm/share/useObjectShareController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useObjectShareController.d.ts","sourceRoot":"","sources":["../../src/share/useObjectShareController.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAiB1E,OAAO,EACH,KAAK,sBAAsB,EAI3B,KAAK,sBAAsB,EAE9B,MAAM,kCAAkC,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,CAAC,EAAE,sBAAsB,GACjC,sBAAsB,CA+kBxB"}
+{"version":3,"file":"useObjectShareController.d.ts","sourceRoot":"","sources":["../../src/share/useObjectShareController.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAkB1E,OAAO,EACH,KAAK,sBAAsB,EAI3B,KAAK,sBAAsB,EAE9B,MAAM,kCAAkC,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,CAAC,EAAE,sBAAsB,GACjC,sBAAsB,CAkxBxB"}