@agent-native/core 0.134.0 → 0.135.0

package/corpus/templates/content/app/components/editor/database/row-access.ts

@@ -0,0 +1,45 @@
+import type { ContentDatabaseItem, ContentDatabaseSource } from "@shared/api";
+
+export function databaseItemIsSourceBacked(
+  item: ContentDatabaseItem,
+  sources: ContentDatabaseSource[],
+) {
+  const membershipHydration = item.document.databaseMembership?.bodyHydration;
+  const hydration = item.bodyHydration ?? membershipHydration;
+  return (
+    item.sourceRecord !== undefined ||
+    item.document.databaseMembership?.sourceId != null ||
+    hydration?.version != null ||
+    (hydration !== undefined && hydration.status !== "hydrated") ||
+    sources.some((source) =>
+      source.rows.some((row) => row.databaseItemId === item.id),
+    )
+  );
+}
+
+export function databaseItemHasViewerAccess(item: ContentDatabaseItem) {
+  return item.document.canView === true;
+}
+
+export function databaseItemCanDuplicate(
+  item: ContentDatabaseItem,
+  isWorkspaceCatalog: boolean,
+) {
+  return !isWorkspaceCatalog && databaseItemHasViewerAccess(item);
+}
+
+export function databaseItemCanRemoveFromDatabase(args: {
+  item: ContentDatabaseItem;
+  databaseCanManage: boolean;
+  databaseSystemRole: string | null | undefined;
+  isWorkspaceCatalog: boolean;
+  sources: ContentDatabaseSource[];
+}) {
+  return (
+    args.databaseCanManage &&
+    args.databaseSystemRole === null &&
+    databaseItemHasViewerAccess(args.item) &&
+    !args.isWorkspaceCatalog &&
+    !databaseItemIsSourceBacked(args.item, args.sources)
+  );
+}

package/corpus/templates/content/app/components/editor/database/shared.tsx

@@ -22,6 +22,7 @@ import {
   IconList,
   IconMinus,
   IconSearch,
+  IconStarOff,
   IconTable,
   IconTimeline,
   IconTrash,
@@ -53,12 +54,26 @@ import {
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
 import { Input } from "@/components/ui/input";
-import { useDuplicateDatabaseItem } from "@/hooks/use-content-database";
-import { useDeleteDocument } from "@/hooks/use-documents";
+import {
+  isContentDatabaseUnavailable,
+  useContentDatabase,
+  useDuplicateDatabaseItem,
+  useRemoveDatabaseItems,
+} from "@/hooks/use-content-database";
+import {
+  useContentSpaces,
+  useDeleteContentSpace,
+} from "@/hooks/use-content-spaces";
+import { useDocument } from "@/hooks/use-documents";
 import { cn } from "@/lib/utils";
 
 import { OPTION_COLOR_CLASSES, TYPE_ICONS } from "../DocumentProperties";
 import { databaseDuplicatedItemFromResponse } from "./navigation-state";
+import {
+  databaseItemCanDuplicate,
+  databaseItemCanRemoveFromDatabase,
+} from "./row-access";
+import { dbText } from "./text";
 import type { DatabaseBoardGroup, DatabaseDropSide } from "./types";
 
 // ---------------------------------------------------------------------------
@@ -518,13 +533,44 @@ export function RowActionsCell({
   onOpenPage: () => void;
 }) {
   const queryClient = useQueryClient();
-  const deleteDocument = useDeleteDocument();
+  const contentSpaces = useContentSpaces();
+  const { data: databaseDocument } = useDocument(databaseDocumentId);
+  const databaseQuery = useContentDatabase(databaseDocumentId);
   const duplicateItem = useDuplicateDatabaseItem(databaseDocumentId);
+  const removeItems = useRemoveDatabaseItems(databaseDocumentId);
+  const deleteContentSpace = useDeleteContentSpace();
   const [menuOpen, setMenuOpen] = useState(false);
   const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
   const title = item.document.title || "Untitled";
+  const removesFavoriteMembership =
+    contentSpaces.data?.favoritesDocumentId === databaseDocumentId;
+  const isWorkspaceCatalog =
+    contentSpaces.data?.catalogDocumentId === databaseDocumentId;
+  const workspaceSpace = contentSpaces.data?.spaces.find(
+    (space) => space.catalogDocumentId === item.document.id,
+  );
+  const canDeleteWorkspace =
+    isWorkspaceCatalog && workspaceSpace?.kind === "user";
+  const databaseData = isContentDatabaseUnavailable(databaseQuery.data)
+    ? undefined
+    : databaseQuery.data;
+  const databaseSources =
+    databaseData?.sources ??
+    (databaseData?.source ? [databaseData.source] : []);
+  const canRemoveFromDatabase = removesFavoriteMembership
+    ? databaseDocument?.canEdit === true
+    : databaseData !== undefined &&
+      databaseItemCanRemoveFromDatabase({
+        item,
+        databaseCanManage: databaseDocument?.canManage === true,
+        databaseSystemRole: databaseData.database.systemRole,
+        isWorkspaceCatalog,
+        sources: databaseSources,
+      });
+  const canDuplicateRow = databaseItemCanDuplicate(item, isWorkspaceCatalog);
 
   async function duplicateRow() {
+    if (!canDuplicateRow) return;
     setMenuOpen(false);
     try {
       const response = await duplicateItem.mutateAsync({ itemId: item.id });
@@ -538,10 +584,21 @@ export function RowActionsCell({
     }
   }
 
-  async function deleteRow() {
+  async function removeRowOrDeleteWorkspace() {
+    if (!canRemoveFromDatabase && !canDeleteWorkspace) {
+      setConfirmDeleteOpen(false);
+      return;
+    }
     const previewMoved = onDeletedPreviewItem?.(item) ?? false;
     try {
-      await deleteDocument.mutateAsync({ id: item.document.id });
+      if (canDeleteWorkspace && workspaceSpace) {
+        await deleteContentSpace.mutateAsync({ spaceId: workspaceSpace.id });
+      } else {
+        await removeItems.mutateAsync({
+          documentId: databaseDocumentId,
+          documentIds: [item.document.id],
+        });
+      }
       await queryClient.invalidateQueries({
         queryKey: [
           "action",
@@ -554,10 +611,15 @@ export function RowActionsCell({
       });
     } catch (err) {
       if (previewMoved) onPreviewItem?.(item);
-      toast.error("Failed to delete row", {
-        description:
-          err instanceof Error ? err.message : "Something went wrong",
-      });
+      toast.error(
+        canDeleteWorkspace
+          ? "Failed to delete workspace"
+          : dbText("failedToRemoveRowFromDatabase"),
+        {
+          description:
+            err instanceof Error ? err.message : "Something went wrong",
+        },
+      );
     }
   }
 
@@ -584,48 +646,89 @@ export function RowActionsCell({
             <IconExternalLink className="mr-2 size-4 text-muted-foreground" />
             Open page
           </DropdownMenuItem>
-          <DropdownMenuItem
-            disabled={duplicateItem.isPending}
-            onSelect={(event) => {
-              event.preventDefault();
-              void duplicateRow();
-            }}
-          >
-            <IconCopy className="mr-2 size-4 text-muted-foreground" />
-            Duplicate row
-          </DropdownMenuItem>
-          <DropdownMenuSeparator />
-          <DropdownMenuItem
-            className="text-destructive focus:bg-destructive/10 focus:text-destructive"
-            onSelect={(event) => {
-              event.preventDefault();
-              setMenuOpen(false);
-              setConfirmDeleteOpen(true);
-            }}
-          >
-            <IconTrash className="mr-2 size-4" />
-            Delete row
-          </DropdownMenuItem>
+          {canDuplicateRow ? (
+            <DropdownMenuItem
+              disabled={duplicateItem.isPending}
+              onSelect={(event) => {
+                event.preventDefault();
+                void duplicateRow();
+              }}
+            >
+              <IconCopy className="mr-2 size-4 text-muted-foreground" />
+              Duplicate row
+            </DropdownMenuItem>
+          ) : null}
+          {canRemoveFromDatabase || canDeleteWorkspace ? (
+            <DropdownMenuSeparator />
+          ) : null}
+          {canRemoveFromDatabase || canDeleteWorkspace ? (
+            <DropdownMenuItem
+              className="text-destructive focus:bg-destructive/10 focus:text-destructive"
+              onSelect={(event) => {
+                event.preventDefault();
+                setMenuOpen(false);
+                if (removesFavoriteMembership) {
+                  void removeRowOrDeleteWorkspace();
+                } else {
+                  setConfirmDeleteOpen(true);
+                }
+              }}
+            >
+              {removesFavoriteMembership ? (
+                <IconStarOff className="mr-2 size-4 text-muted-foreground" />
+              ) : (
+                <IconTrash className="mr-2 size-4" />
+              )}
+              {removesFavoriteMembership
+                ? "Remove from favorites"
+                : canDeleteWorkspace
+                  ? "Delete workspace"
+                  : dbText("removeFromDatabase")}
+            </DropdownMenuItem>
+          ) : null}
         </DropdownMenuContent>
       </DropdownMenu>
 
-      <AlertDialog open={confirmDeleteOpen} onOpenChange={setConfirmDeleteOpen}>
+      <AlertDialog
+        open={
+          !removesFavoriteMembership &&
+          (canRemoveFromDatabase || canDeleteWorkspace) &&
+          confirmDeleteOpen
+        }
+        onOpenChange={setConfirmDeleteOpen}
+      >
         <AlertDialogContent>
           <AlertDialogHeader>
-            <AlertDialogTitle>Delete row?</AlertDialogTitle>
+            <AlertDialogTitle>
+              {canDeleteWorkspace
+                ? "Delete workspace?"
+                : dbText("removeFromDatabaseQuestion")}
+            </AlertDialogTitle>
             <AlertDialogDescription>
-              &ldquo;{title}&rdquo; and any sub-pages will be permanently
-              deleted. This cannot be undone.
+              {canDeleteWorkspace ? (
+                <>
+                  &ldquo;{title}&rdquo; and every page and database inside it
+                  will be permanently deleted. This cannot be undone.
+                </>
+              ) : (
+                dbText("removeFromDatabaseDescription", { title })
+              )}
             </AlertDialogDescription>
           </AlertDialogHeader>
           <AlertDialogFooter>
             <AlertDialogCancel>Cancel</AlertDialogCancel>
             <AlertDialogAction
               className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
-              disabled={deleteDocument.isPending}
-              onClick={() => void deleteRow()}
+              disabled={removeItems.isPending || deleteContentSpace.isPending}
+              onClick={() => void removeRowOrDeleteWorkspace()}
             >
-              {deleteDocument.isPending ? "Deleting..." : "Delete"}
+              {removeItems.isPending || deleteContentSpace.isPending
+                ? canDeleteWorkspace
+                  ? "Deleting..."
+                  : dbText("removing")
+                : canDeleteWorkspace
+                  ? "Delete"
+                  : dbText("remove")}
             </AlertDialogAction>
           </AlertDialogFooter>
         </AlertDialogContent>

package/corpus/templates/content/app/components/ui/switch.tsx

@@ -0,0 +1 @@
+export * from "@agent-native/toolkit/ui/switch";

package/corpus/templates/content/app/hooks/use-content-database.ts

@@ -927,10 +927,10 @@ export function useDuplicateDatabaseItems(documentId: string) {
   );
 }
 
-export function useDeleteDatabaseItems(documentId: string) {
+export function useRemoveDatabaseItems(documentId: string) {
   const queryClient = useQueryClient();
   return useActionMutation<ContentDatabaseResponse, DatabaseItemsBatchRequest>(
-    "delete-database-items",
+    "remove-database-items",
     {
       onSuccess: () => {
         queryClient.invalidateQueries({

package/corpus/templates/content/app/hooks/use-content-prefs.ts

@@ -0,0 +1,55 @@
+import { agentNativePath } from "@agent-native/core/client/api-path";
+import type { ContentUserPrefs } from "@shared/content-user-prefs";
+import { useCallback, useEffect, useState } from "react";
+
+const PREFS_PATH = "/_agent-native/content/user-prefs";
+
+export interface ContentPrefsState {
+  prefs: ContentUserPrefs;
+  loading: boolean;
+  /** Applies the patch optimistically and rolls back if the write fails. */
+  save: (patch: ContentUserPrefs) => Promise<void>;
+}
+
+export function useContentPrefs(): ContentPrefsState {
+  const [prefs, setPrefs] = useState<ContentUserPrefs>({});
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      try {
+        const res = await fetch(agentNativePath(PREFS_PATH));
+        const json = res.ok ? await res.json() : null;
+        if (cancelled) return;
+        if (json && typeof json === "object" && !("error" in json)) {
+          setPrefs(json as ContentUserPrefs);
+        }
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  const save = useCallback(
+    async (patch: ContentUserPrefs) => {
+      const previous = prefs;
+      setPrefs((current) => ({ ...current, ...patch }));
+      const res = await fetch(agentNativePath(PREFS_PATH), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(patch),
+      });
+      if (!res.ok) {
+        setPrefs(previous);
+        throw new Error(`Save failed (${res.status})`);
+      }
+    },
+    [prefs],
+  );
+
+  return { prefs, loading, save };
+}