@manta-eu/react 0.1.10 → 0.2.0

package/src/components/table-skeleton/index.tsx

@@ -9,14 +9,19 @@ export type TableSkeletonProps = {
   renderRow: (rowIndex: number) => ReactNode;
   withWrapper?: boolean;
   className?: string;
+  headerClassName?: string;
+  rowClassName?: string;
 };
 
 export function TableSkeleton(props: TableSkeletonProps) {
   const { gridColsClassName, headerColumnCount, rows = 8, renderRow, withWrapper = true, className } = props;
+  const { headerClassName, rowClassName } = props;
 
   const content = (
     <>
-      <div className={cn("grid gap-3 border-b border-muted-border bg-faint px-4 py-3", gridColsClassName)}>
+      <div
+        className={cn("grid gap-3 border-b border-muted-border bg-faint px-4 py-3", gridColsClassName, headerClassName)}
+      >
         {Array.from({ length: headerColumnCount }, (_, index) => (
           <Skeleton key={`table-skeleton-header-${index}`} className="h-4 w-2/3 rounded-md" />
         ))}
@@ -27,6 +32,7 @@ export function TableSkeleton(props: TableSkeletonProps) {
           className={cn(
             "grid items-center gap-3 border-b border-muted-border px-4 py-4 last:border-b-0",
             gridColsClassName,
+            rowClassName,
           )}
         >
           {renderRow(rowIndex)}

package/src/graph/createNodeRouter.tsx

@@ -12,7 +12,7 @@ import { AttioNoteView } from "./nodes/AttioNoteView";
 import { AttioTaskView } from "./nodes/AttioTaskView";
 import { BrandAssetAnalysisActionView } from "./nodes/BrandAssetAnalysisActionView";
 import { BrandAssetAnalysisView } from "./nodes/BrandAssetAnalysisView";
-import { BrandFontFamilyView } from "./nodes/BrandFontFamilyView";
+import { BrandFontSuggestionView } from "./nodes/BrandFontSuggestionView";
 import { BrandGuidelinesView } from "./nodes/BrandGuidelinesView";
 import { CoresignalCompanyView } from "./nodes/CoresignalCompanyView";
 import { CoresignalEmployeeView } from "./nodes/CoresignalEmployeeView";
@@ -123,7 +123,7 @@ const typedNodeEntries: ReadonlyArray<readonly [IRI, EntityView]> = [
   // Asserted by a Datalog rule, not by a node shape, so codegen emits no class term for it.
   [expandPrefix("brand:AssetAnalysis"), BrandAssetAnalysisView],
   [brand.BrandGuidelines, BrandGuidelinesView],
-  [brand.FontFamily, BrandFontFamilyView],
+  [brand.FontSuggestion, BrandFontSuggestionView],
 ];
 
 export const typedEntityTypeIris: ReadonlySet<IRI> = new Set(typedNodeEntries.map(([type]) => type as IRI));
@@ -135,7 +135,7 @@ export const diffSubsumingViewIris: ReadonlySet<IRI> = new Set([
   expandPrefix("brand:AssetAnalysisShape"),
   expandPrefix("brand:AssetAnalysis"),
   brand.BrandGuidelines,
-  brand.FontFamily,
+  brand.FontSuggestion,
 ]);
 
 export const typedActionShapeIris: ReadonlySet<IRI> = new Set(actionShapeNodeEntries.map(([iri]) => iri));

package/src/graph/nodes/{BrandFontFamilyView.tsx → BrandFontSuggestionView.tsx}

@@ -1,4 +1,4 @@
-import { BrandFontFileSchema } from "@manta-eu/ldo";
+import { BrandFontFileSchema, BrandSuggestedWeightSchema } from "@manta-eu/ldo";
 import { redirectPath } from "@manta-eu/ldo/redirect-queries";
 import { isPresent } from "@manta-eu/lib/present";
 import { namespaces } from "@manta-eu/rdf-lib/namespaces";
@@ -8,11 +8,13 @@ import type { EntityViewProps } from "../types";
 import {
   fontFaceDescriptors,
   preferredFontFile,
+  sortedWeights,
   specimenWeight,
+  weightLabel,
   type StoredFontFile,
+  type SuggestedWeight,
 } from "./brand-font";
 import { BrandNodeBody, BrandStatusBadge } from "./brand-shared";
-import { BrandFontUploadButton } from "./BrandFontUploadButton";
 import { EntityCardShell } from "./EntityCardShell";
 import { NodePropertyTable } from "./NodePropertyTable";
 import { readBrandString, toIriArray } from "./typed-node-helpers";
@@ -20,11 +22,26 @@ import { useEntitiesByIris } from "#hooks/use-entity";
 import { useFontFace } from "#hooks/use-font-face";
 import { useRedirectEndpoint } from "#hooks/use-redirect-endpoint";
 
-const statusPredicate = `${namespaces.brand}entryStatus`;
-const availabilityPredicate = `${namespaces.brand}fontAvailability`;
-const fontFilePredicate = `${namespaces.brand}fontFile`;
+const weightPredicate = `${namespaces.brand}hasSuggestedWeight`;
 const specimenText = "Aa Bb Cc Qq Rr 0123456789 — The quick brown fox jumps over the lazy dog";
 
+function useSuggestedWeights(iris: string[]): SuggestedWeight[] {
+  const { data } = useEntitiesByIris({ schema: BrandSuggestedWeightSchema, iris });
+
+  return (data ?? []).flatMap((weight) =>
+    weight
+      ? [
+          {
+            weight: weight.fontWeight,
+            style: weight.fontStyle,
+            availability: weight.fontAvailability,
+            coveringFiles: weight.coveringFile ?? [],
+          },
+        ]
+      : [],
+  );
+}
+
 function useStoredFontFiles(iris: string[]): StoredFontFile[] {
   const { data } = useEntitiesByIris({ schema: BrandFontFileSchema, iris });
 
@@ -69,48 +86,39 @@ function FontSpecimen(props: FontSpecimenProps) {
   );
 }
 
-export const BrandFontFamilyView = memo(function BrandFontFamilyView(props: EntityViewProps) {
+export const BrandFontSuggestionView = memo(function BrandFontSuggestionView(props: EntityViewProps) {
   const { data, selected = false, ringColor, onContextMenu } = props;
 
   const family = readBrandString(data.jsonLd, "family") ?? data.label;
-  const status = readBrandString(data.jsonLd, "entryStatus");
-  const availability = readBrandString(data.jsonLd, "fontAvailability");
-  const fileIris = toIriArray(data.jsonLd[fontFilePredicate] ?? data.jsonLd["brand:fontFile"]);
-  const file = preferredFontFile(useStoredFontFiles(fileIris));
+  const weights = sortedWeights(
+    useSuggestedWeights(toIriArray(data.jsonLd[weightPredicate] ?? data.jsonLd["brand:hasSuggestedWeight"])),
+  );
+  const file = preferredFontFile(useStoredFontFiles([...new Set(weights.flatMap((weight) => weight.coveringFiles))]));
 
   return (
     <EntityCardShell
       icon={Type}
-      label={`Font Family: ${family}`}
+      label={`Font Suggestion: ${family}`}
       labelMaxWidth="max-w-140"
       selected={selected}
       ringColor={ringColor}
       onContextMenu={onContextMenu}
     >
-      <BrandNodeBody
-        right={
-          <div className="flex items-center gap-1">
-            <BrandStatusBadge status={availability} />
-            <BrandStatusBadge status={status} />
-          </div>
-        }
-      >
+      <BrandNodeBody>
         {isPresent(file) && <FontSpecimen file={file} />}
 
-        {isPresent(availability) && availability !== "available" && (
-          <div className="flex items-center justify-between gap-2">
-            {availability === "needs-upload" && (
-              <span className="typography-tiny text-muted-foreground">No font file found for this family.</span>
-            )}
-            <BrandFontUploadButton family={family} />
-          </div>
+        {isPresent(weights) && (
+          <ul className="flex flex-col gap-1">
+            {weights.map((weight) => (
+              <li key={weightLabel(weight)} className="flex items-center justify-between gap-2">
+                <span className="typography-tiny text-default-foreground">{weightLabel(weight)}</span>
+                <BrandStatusBadge status={weight.availability} />
+              </li>
+            ))}
+          </ul>
         )}
 
-        <NodePropertyTable
-          properties={data.properties}
-          jsonLd={data.jsonLd}
-          omitPredicates={[statusPredicate, availabilityPredicate]}
-        />
+        <NodePropertyTable properties={data.properties} jsonLd={data.jsonLd} omitPredicates={[weightPredicate]} />
       </BrandNodeBody>
     </EntityCardShell>
   );

package/src/graph/nodes/brand-font.ts

@@ -27,3 +27,20 @@ export function fontFaceDescriptors(file: StoredFontFile): FontFaceDescriptors {
 export function specimenWeight(file: StoredFontFile): number {
   return Math.min(Math.max(400, file.weightMin), file.weightMax);
 }
+
+export type SuggestedWeight = {
+  weight: number;
+  style: "normal" | "italic";
+  availability: "available" | "looking-up" | "needs-upload";
+  coveringFiles: readonly string[];
+};
+
+export function sortedWeights<W extends Pick<SuggestedWeight, "weight" | "style">>(weights: readonly W[]): W[] {
+  return [...weights].sort(
+    (a, b) => a.weight - b.weight || Number(a.style === "italic") - Number(b.style === "italic"),
+  );
+}
+
+export function weightLabel(weight: Pick<SuggestedWeight, "weight" | "style">): string {
+  return weight.style === "italic" ? `${weight.weight} italic` : `${weight.weight}`;
+}

package/src/graph/nodes/brand-shared.tsx

@@ -11,14 +11,11 @@ import { cn } from "#style";
 
 export const brandAmber = "#d97706";
 
-// Every `sh:in` value on the brand status paths in kgc/shacl/shapes/brand.ttl; an unlisted one means a shape moved on.
+// Every `sh:in` value of brand:fontAvailability in kgc/shacl/shapes/brand-font-suggestion.ttl.
 const toneByStatus = {
-  accepted: "positive",
   available: "positive",
-  draft: "neutral",
   "looking-up": "neutral",
   "needs-upload": "caution",
-  rejected: "negative",
 } as const satisfies Record<string, BadgeTone>;
 
 export type BrandStatus = keyof typeof toneByStatus;

package/src/hooks/useAuth.ts

@@ -26,7 +26,7 @@ export type UseAuthResult = {
   isAuthenticated: boolean;
   isOperator: boolean;
   canManageTeam: boolean;
-  canManageExternalApps: boolean;
+  canManageCustomApps: boolean;
   orgRoles: OrgRoleDefinition[];
   canManageIntegrations: boolean;
   canManageStreams: boolean;
@@ -79,7 +79,7 @@ export const contextResponseSchema = z.object({
     canManageStreams: z.boolean().optional().default(false),
     canManageSharedMemories: z.boolean().optional().default(false),
     canManageTeam: z.boolean().optional().default(false),
-    canManageExternalApps: z.boolean().optional().default(false),
+    canManageCustomApps: z.boolean().optional().default(false),
     datastore: datastoreSchema.nullish(),
   }),
   datastores: z.array(datastoreSchema),
@@ -297,7 +297,7 @@ export function useAuth(): UseAuthResult {
     datastoreAccessGranted: contextData?.datastoreAccessGranted ?? true,
     isOperator: contextData?.user?.isOperator ?? false,
     canManageTeam: contextData?.user?.canManageTeam ?? false,
-    canManageExternalApps: contextData?.user?.canManageExternalApps ?? false,
+    canManageCustomApps: contextData?.user?.canManageCustomApps ?? false,
     orgRoles: contextData?.orgRoles ?? [],
     canManageIntegrations: contextData?.user?.canManageIntegrations ?? false,
     canManageStreams: contextData?.user?.canManageStreams ?? false,

package/src/hooks/useOnboardingState.ts

@@ -1,7 +1,7 @@
+import { onboardingCompletedCookieName as onboardingCookieName } from "@manta-eu/client/shared/constants";
 import Cookies from "js-cookie";
 import { useCallback, useState } from "react";
 
-const onboardingCookieName = "manta-onboarding-completed";
 const onboardingCookieExpiryDays = 365;
 
 type OnboardingState = {

package/src/lib/datastore-route-table.ts

@@ -17,7 +17,8 @@ export type RouteElements = {
   Integrations?: ReactNode;
   ShopifyConnect?: ReactNode;
   Team?: ReactNode;
-  ExternalApps?: ReactNode;
+  CustomApps?: ReactNode;
+  CustomAppUsers?: ReactNode;
   DataExplorerLayout?: ReactNode;
   DataExplorerIndex?: ReactNode;
   DataExplorerRecent?: ReactNode;
@@ -45,7 +46,8 @@ export const globalRoutes: RouteDefinition[] = [
   { path: "/datastores", render: (e) => e.Datastores || notFoundElement(e) },
   // Global, not datastore-scoped: Shopify sends the merchant here before any datastore is known.
   { path: "/shopify/connect", render: (e) => e.ShopifyConnect || notFoundElement(e) },
-  { path: "/custom-apps", render: (e) => e.ExternalApps || notFoundElement(e) },
+  { path: "/custom-apps", render: (e) => e.CustomApps || notFoundElement(e) },
+  { path: "/custom-apps/:clientId/users", render: (e) => e.CustomAppUsers || notFoundElement(e) },
 ];
 
 export const datastoreRoutes: RouteDefinition[] = [

package/src/providers/AuthContext.ts

@@ -9,7 +9,7 @@ export type AuthContextValue = Pick<
   | "logout"
   | "isOperator"
   | "canManageTeam"
-  | "canManageExternalApps"
+  | "canManageCustomApps"
   | "orgRoles"
   | "canManageIntegrations"
   | "canManageStreams"
@@ -18,6 +18,8 @@ export type AuthContextValue = Pick<
   | "allowedModels"
 > & {
   user: User;
+  // Only Manta's own web app may list the apps connected to someone; any other host's token is refused.
+  canDisconnectCustomApps?: boolean;
 };
 
 export const AuthContext = createContext<AuthContextValue | undefined>(undefined);

package/src/providers/ChatManagerProvider.tsx

@@ -80,6 +80,7 @@ export function ChatManagerProvider(props: ChatManagerProviderProps) {
   const conversationSelectionRef = useRef(conversationSelection);
   const pathnameRef = useRef(location.pathname);
   const routedConversationIdRef = useRef(routedConversationId);
+  const pendingPlanNavigationRef = useRef<{ pathname: string } | undefined>(undefined);
 
   // Where navigate() was last sent, which react-router's deferred location has not reached yet.
   const requestedPathRef = useRef(location.pathname);
@@ -351,7 +352,11 @@ export function ChatManagerProvider(props: ChatManagerProviderProps) {
   );
 
   const selectContext = useCallback(
-    (context: ChatContext): Promise<void> => transitionContext({ kind: "select", context }).then(() => undefined),
+    (context: ChatContext): Promise<void> => {
+      // The current page may synchronize its old context while an explicit plan selection is waiting.
+      if (pendingPlanNavigationRef.current?.pathname === pathnameRef.current) return Promise.resolve();
+      return transitionContext({ kind: "select", context }).then(() => undefined);
+    },
     [transitionContext],
   );
 
@@ -390,17 +395,20 @@ export function ChatManagerProvider(props: ChatManagerProviderProps) {
 
       const context = { kind: ChatContextKind.Plan, planGraphIri: planIri } as const;
       const source = activeConversationFromSelection(conversationSelectionRef.current);
-      if (source) {
-        try {
+      const navigation = { pathname: pathnameRef.current };
+      pendingPlanNavigationRef.current = navigation;
+      try {
+        if (source) {
           const transitioned = await reassignCurrentConversation(context);
           if (!transitioned) return;
-        } catch {
-          toast.error("Couldn't move this chat to the plan. Please try again.");
-          return;
         }
-      }
 
-      void navigate(buildPlanHref(planIri), { state: { fromChat: true } });
+        void navigate(buildPlanHref(planIri), { state: { fromChat: true } });
+      } catch {
+        toast.error("Couldn't move this chat to the plan. Please try again.");
+      } finally {
+        if (pendingPlanNavigationRef.current === navigation) pendingPlanNavigationRef.current = undefined;
+      }
     },
     [navigate, onSelectPlan, reassignCurrentConversation],
   );

package/src/routes/data-explorer/declared-namespaces.ts

@@ -1,22 +1,29 @@
-import { ontologyGraphIri } from "@manta-eu/client/shared/rdf-namespaces";
+import { expandPrefix, ontologyGraphIri } from "@manta-eu/client/shared/rdf-namespaces";
 import { isPresent } from "@manta-eu/lib/present";
 import { DataFactory, type RDF } from "ldkit/rdf";
 import { SELECT } from "ldkit/sparql";
 import { useMemo } from "react";
-import { prefixes, registerDeclaredNamespaces, type DeclaredNamespace } from "./namespaces";
+import { prefixes, realmPath, registerDeclaredNamespaces, type DeclaredNamespace } from "./namespaces";
 import { bindingValue, useSparqlSelect } from "#ldo-ui";
 
 const df = new DataFactory();
 
-const declaredNamespacesQuery = `${prefixes}${SELECT`?prefix ?namespace ?source ?title ?sourceLabel`.WHERE`
-  GRAPH ${df.namedNode(ontologyGraphIri)} {
-    [] sh:declare ?declaration .
-    ?declaration sh:prefix ?prefix ; sh:namespace ?namespace .
-    OPTIONAL {
-      ?declaration rdfs:isDefinedBy ?source .
-      OPTIONAL { ?source dcterms:title ?title }
-      OPTIONAL { ?source rdfs:label ?sourceLabel }
+const declaredNamespacesQuery = `${prefixes}${SELECT`?prefix ?namespace ?source ?title ?sourceLabel ?connectionName`
+  .WHERE`
+  {
+    GRAPH ${df.namedNode(ontologyGraphIri)} {
+      [] sh:declare ?declaration .
+      ?declaration sh:prefix ?prefix ; sh:namespace ?namespace .
+      OPTIONAL {
+        ?declaration rdfs:isDefinedBy ?source .
+        OPTIONAL { ?source dcterms:title ?title }
+        OPTIONAL { ?source rdfs:label ?sourceLabel }
+      }
     }
+  } UNION {
+    ?declaration a sh:PrefixDeclaration ; sh:namespace ?namespace ; schema:identifier ?id .
+    ?connection a ${df.namedNode(expandPrefix(":DataConnection"))} ; schema:identifier ?id ; schema:name ?connectionName .
+    FILTER NOT EXISTS { ?connection ${df.namedNode(expandPrefix(":deletedAt"))} ?deleted }
   }
 `.build()}`;
 
@@ -28,15 +35,16 @@ function sourceFrom(binding: RDF.Bindings) {
   return { iri, label: bindingValue(binding, "title") ?? bindingValue(binding, "sourceLabel") ?? iri };
 }
 
-function declaredNamespacesFrom(bindings: RDF.Bindings[]): Record<string, DeclaredNamespace> {
+export function declaredNamespacesFrom(bindings: RDF.Bindings[]): Record<string, DeclaredNamespace> {
   return Object.fromEntries(
     bindings.flatMap<[string, DeclaredNamespace]>((binding) => {
-      const prefix = bindingValue(binding, "prefix");
       const iri = bindingValue(binding, "namespace");
+      const connectionName = bindingValue(binding, "connectionName");
+      const prefix = isPresent(connectionName) && isPresent(iri) ? realmPath(iri) : bindingValue(binding, "prefix");
 
       if (!isPresent(prefix) || !isPresent(iri)) return [];
 
-      return [[prefix, { iri, label: prefix, source: sourceFrom(binding) }]];
+      return [[prefix, { iri, label: connectionName ?? prefix, source: sourceFrom(binding) }]];
     }),
   );
 }

package/src/routes/data-explorer/namespaces.ts

@@ -78,12 +78,13 @@ export function prefixForIri(iri: string): string | undefined {
 
   if (registered) return registered;
 
-  if (!iri.startsWith(realmVocabRoot)) return undefined;
+  return realmPath(iri);
+}
 
-  const rest = iri.slice(realmVocabRoot.length);
-  const segment = rest.split(/[#/]/)[0];
+export function realmPath(iri: string): string | undefined {
+  if (!iri.startsWith(realmVocabRoot) || !iri.includes("#")) return undefined;
 
-  return rest.startsWith(`${segment}#`) ? segment || undefined : undefined;
+  return iri.slice(realmVocabRoot.length).split("#")[0] || undefined;
 }
 
 export function localName(iri: string, prefix: string): string {
@@ -118,11 +119,11 @@ export function groupCrumb(prefix: string): { label: string; to: string } {
 }
 
 export function classPath(prefix: string, name: string): string {
-  return `${explorerPath}/${prefix}/${name}`;
+  return `${namespacePath(prefix)}/${name}`;
 }
 
 export function recordPath(prefix: string, type: string, id: string): string {
-  return `${explorerPath}/${prefix}/${type}/${encodeURIComponent(id)}`;
+  return `${classPath(prefix, type)}/${encodeURIComponent(id)}`;
 }
 
 export type ClassRef = { iri: string; prefix: string; localName: string; path: string };

package/src/routes/datastores/components/DeleteDatastoreDialog.tsx

@@ -0,0 +1,78 @@
+import { useState } from "react";
+import type { DatastoreRow } from "../flatten";
+import { Button } from "#components/button/index";
+import { Input } from "#components/input/index";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "#components/modal/index";
+
+type DeleteDatastoreDialogProps = {
+  target: DatastoreRow;
+  isDeleting: boolean;
+  onConfirm: (confirmName: string) => void;
+  onCancel: () => void;
+};
+
+export function DeleteDatastoreDialog(props: DeleteDatastoreDialogProps) {
+  const { target, isDeleting, onConfirm, onCancel } = props;
+  const [typed, setTyped] = useState("");
+
+  const canDelete = typed.trim() === target.name.trim() && !isDeleting;
+  const deletesOrganization = target.isOrganization && target.mirrored !== true;
+
+  function confirm() {
+    if (canDelete) onConfirm(target.name);
+  }
+
+  return (
+    <Dialog open onOpenChange={(nextOpen) => !nextOpen && !isDeleting && onCancel()}>
+      <DialogContent className="flex flex-col overflow-hidden" showCloseButton={!isDeleting}>
+        <DialogHeader>
+          <DialogTitle
+            text={deletesOrganization ? "Delete organization permanently" : "Delete datastore permanently"}
+          />
+          <DialogDescription>This can't be undone. Deleting &quot;{target.name}&quot; removes:</DialogDescription>
+        </DialogHeader>
+
+        <ul className="list-disc pl-5 typography-small text-muted-foreground">
+          <li>its knowledge graph and everything in it</li>
+          <li>its connected integrations and their secrets</li>
+          <li>its uploaded files and chats</li>
+          {deletesOrganization && <li>the organization, its groups and memberships</li>}
+          {!target.isOrganization && !target.isUnlinked && <li>the group and its memberships</li>}
+        </ul>
+        {target.isOrganization && !deletesOrganization && (
+          <p className="typography-small text-muted-foreground">
+            The organization itself stays, because the identity provider holds it. It is listed as having no datastore
+            afterwards.
+          </p>
+        )}
+
+        <Input
+          autoFocus
+          label={`Type "${target.name}" to confirm`}
+          value={typed}
+          disabled={isDeleting}
+          onChange={(event) => setTyped(event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key === "Enter") confirm();
+          }}
+        />
+
+        <DialogFooter>
+          <Button variant="tertiary" onClick={onCancel} disabled={isDeleting}>
+            Cancel
+          </Button>
+          <Button variant="destructive" onClick={confirm} disabled={!canDelete} isLoading={isDeleting}>
+            Delete permanently
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/routes/datastores/flatten.ts

@@ -79,6 +79,21 @@ export function visibleDatastoreRows(rows: DatastoreRow[], visibility: Datastore
   return rows.filter((_row, index) => shown[index] || hasVisibleDescendant(rows, shown, index));
 }
 
+// The server refuses to delete a datastore while others live under it.
+export function nestedDatastoreNamesByRowId(rows: DatastoreRow[]): Map<string, string[]> {
+  const nested = new Map<string, string[]>();
+  rows.forEach((row, index) => {
+    const names: string[] = [];
+    for (let i = index + 1; i < rows.length; i++) {
+      const descendant = rows[i];
+      if (!descendant || descendant.depth <= row.depth) break;
+      if (isPresent(descendant.datastoreId)) names.push(descendant.name);
+    }
+    if (isPresent(names)) nested.set(row.id, names);
+  });
+  return nested;
+}
+
 export function hiddenRowCount(
   rows: DatastoreRow[],
   visibility: DatastoreRowVisibility,