@agent-native/core 0.128.1 → 0.128.3

package/corpus/templates/content/actions/move-database-item.ts

@@ -6,6 +6,10 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
+import {
+  databaseItemsPositionScope,
+  withPositionLock,
+} from "./_position-utils.js";
 
 function clamp(value: number, min: number, max: number) {
   return Math.min(Math.max(value, min), max);
@@ -21,13 +25,15 @@ function positionCaseSql(
 }
 
 export default defineAction({
-  description: "Move a page row to a new position in a content database.",
+  description:
+    "Move an exact page membership to a new position in a content database without changing the page's parent or access.",
   schema: z.object({
+    databaseId: z.string().optional().describe("Database ID"),
     itemId: z.string().optional().describe("Database item ID"),
     documentId: z.string().optional().describe("Database row document ID"),
     position: z.coerce.number().int().describe("New zero-based row position"),
   }),
-  run: async ({ itemId, documentId, position }) => {
+  run: async ({ databaseId, itemId, documentId, position }) => {
     if (!itemId && !documentId) {
       throw new Error("Either itemId or documentId is required.");
     }
@@ -48,6 +54,9 @@ export default defineAction({
           itemId
             ? eq(schema.contentDatabaseItems.id, itemId)
             : eq(schema.contentDatabaseItems.documentId, documentId!),
+          databaseId
+            ? eq(schema.contentDatabaseItems.databaseId, databaseId)
+            : undefined,
           isNull(schema.contentDatabases.deletedAt),
         ),
       );
@@ -56,63 +65,73 @@ export default defineAction({
 
     await assertAccess("document", row.database.documentId, "editor");
 
-    const items = await db
-      .select()
-      .from(schema.contentDatabaseItems)
-      .where(eq(schema.contentDatabaseItems.databaseId, row.item.databaseId))
-      .orderBy(asc(schema.contentDatabaseItems.position));
-
-    const currentIndex = items.findIndex((item) => item.id === row.item.id);
-    if (currentIndex < 0) throw new Error("Database row not found.");
+    await withPositionLock(
+      databaseItemsPositionScope(row.item.databaseId),
+      () =>
+        db.transaction(async (tx) => {
+          const items = await tx
+            .select()
+            .from(schema.contentDatabaseItems)
+            .where(
+              eq(schema.contentDatabaseItems.databaseId, row.item.databaseId),
+            )
+            .orderBy(asc(schema.contentDatabaseItems.position));
+          const currentIndex = items.findIndex(
+            (item) => item.id === row.item.id,
+          );
+          if (currentIndex < 0) throw new Error("Database row not found.");
 
-    const nextIndex = clamp(position, 0, items.length - 1);
-    if (nextIndex === currentIndex) {
-      return getContentDatabaseResponse(row.item.databaseId);
-    }
+          const nextIndex = clamp(position, 0, items.length - 1);
+          if (nextIndex === currentIndex) return;
 
-    const nextItems = [...items];
-    const [moved] = nextItems.splice(currentIndex, 1);
-    nextItems.splice(nextIndex, 0, moved);
-    const now = new Date().toISOString();
-    const itemIds = nextItems.map((item) => item.id);
-    const documentIds = nextItems.map((item) => item.documentId);
+          const nextItems = [...items];
+          const [moved] = nextItems.splice(currentIndex, 1);
+          nextItems.splice(nextIndex, 0, moved);
+          const now = new Date().toISOString();
+          const itemIds = nextItems.map((item) => item.id);
+          const documentIds = nextItems.map((item) => item.documentId);
 
-    await db.transaction(async (tx) => {
-      await tx
-        .update(schema.contentDatabaseItems)
-        .set({
-          position: positionCaseSql(
-            schema.contentDatabaseItems.id,
-            schema.contentDatabaseItems.position,
-            itemIds,
-          ),
-          updatedAt: now,
-        })
-        .where(
-          and(
-            eq(schema.contentDatabaseItems.databaseId, row.item.databaseId),
-            inArray(schema.contentDatabaseItems.id, itemIds),
-          ),
-        );
+          await tx
+            .update(schema.contentDatabaseItems)
+            .set({
+              position: positionCaseSql(
+                schema.contentDatabaseItems.id,
+                schema.contentDatabaseItems.position,
+                itemIds,
+              ),
+              updatedAt: now,
+            })
+            .where(
+              and(
+                eq(schema.contentDatabaseItems.databaseId, row.item.databaseId),
+                inArray(schema.contentDatabaseItems.id, itemIds),
+              ),
+            );
 
-      await tx
-        .update(schema.documents)
-        .set({
-          position: positionCaseSql(
-            schema.documents.id,
-            schema.documents.position,
-            documentIds,
-          ),
-          updatedAt: now,
-        })
-        .where(
-          and(
-            eq(schema.documents.ownerEmail, row.database.ownerEmail),
-            eq(schema.documents.parentId, row.database.documentId),
-            inArray(schema.documents.id, documentIds),
-          ),
-        );
-    });
+          if (
+            row.database.systemRole !== "favorites" &&
+            row.database.systemRole !== "workspaces"
+          ) {
+            await tx
+              .update(schema.documents)
+              .set({
+                position: positionCaseSql(
+                  schema.documents.id,
+                  schema.documents.position,
+                  documentIds,
+                ),
+                updatedAt: now,
+              })
+              .where(
+                and(
+                  eq(schema.documents.ownerEmail, row.database.ownerEmail),
+                  eq(schema.documents.parentId, row.database.documentId),
+                  inArray(schema.documents.id, documentIds),
+                ),
+              );
+          }
+        }),
+    );
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 

package/corpus/templates/content/actions/reorder-document-property.ts

@@ -15,6 +15,12 @@ export default defineAction({
     "Reorder a property definition within its database by moving it before or after another property. Used for reordering Blocks fields on the page.",
   schema: z.object({
     documentId: z.string().describe("Document ID used to scope access"),
+    databaseId: z
+      .string()
+      .optional()
+      .describe(
+        "Database ID that owns the properties; omit only for context-free entry points",
+      ),
     propertyId: z.string().describe("Property definition ID to move"),
     targetPropertyId: z.string().describe("Property to position relative to"),
     position: z
@@ -22,11 +28,21 @@ export default defineAction({
       .default("before")
       .describe("Place the moved property before or after the target"),
   }),
-  run: async ({ documentId, propertyId, targetPropertyId, position }) => {
+  run: async ({
+    documentId,
+    databaseId,
+    propertyId,
+    targetPropertyId,
+    position,
+  }) => {
     const access = await assertAccess("document", documentId, "editor");
     const document = access.resource;
     const db = getDb();
-    const database = await resolvePropertyDatabaseForDocument(document);
+    const database = await resolvePropertyDatabaseForDocument(
+      document,
+      databaseId,
+      "editor",
+    );
     if (!database) throw new Error("Document is not part of a database.");
 
     const definitions = await db
@@ -55,7 +71,7 @@ export default defineAction({
       return {
         documentId,
         databaseId: database.id,
-        properties: await listPropertiesForDocument(document),
+        properties: await listPropertiesForDocument(document, database.id),
       };
     }
 
@@ -83,7 +99,7 @@ export default defineAction({
     return {
       documentId,
       databaseId: database.id,
-      properties: await listPropertiesForDocument(document),
+      properties: await listPropertiesForDocument(document, database.id),
     };
   },
 });

package/corpus/templates/content/actions/set-document-property.ts

@@ -26,10 +26,16 @@ export default defineAction({
   description: "Set a Notion-style property value on a document.",
   schema: z.object({
     documentId: z.string().describe("Document ID (required)"),
+    databaseId: z
+      .string()
+      .optional()
+      .describe(
+        "Database ID that owns the property; omit only for context-free entry points",
+      ),
     propertyId: z.string().describe("Property definition ID"),
     value: z.unknown().describe("Value for the property type"),
   }),
-  run: async ({ documentId, propertyId, value }) => {
+  run: async ({ documentId, databaseId, propertyId, value }) => {
     const db = getDb();
     const [definition] = await db
       .select()
@@ -39,6 +45,9 @@ export default defineAction({
     if (!definition.databaseId) {
       throw new Error(`Property "${propertyId}" is not attached to a database`);
     }
+    if (databaseId && definition.databaseId !== databaseId) {
+      throw new Error(`Property "${propertyId}" not found`);
+    }
     const database = await getDatabaseById(definition.databaseId);
     if (!database) throw new Error("Document database not found.");
     await assertAccess("document", database.documentId, "editor");

package/corpus/templates/content/actions/update-content-database-personal-view.ts

@@ -4,9 +4,11 @@ import { z } from "zod";
 
 import {
   assertContentDatabaseViewerAccess,
+  normalizePersonalDatabaseViewOverrides,
   personalDatabaseViewSettingKey,
   personalViewOverridesSchema,
 } from "./_content-database-personal-view.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
 
 export default defineAction({
   description:
@@ -21,6 +23,11 @@ export default defineAction({
 
     const key = personalDatabaseViewSettingKey(databaseId);
     if (overrides) {
+      const visibleDatabase = await getContentDatabaseResponse(databaseId);
+      overrides = normalizePersonalDatabaseViewOverrides(
+        overrides,
+        new Set(visibleDatabase.items.map((item) => item.id)),
+      );
       await putUserSetting(ctx.userEmail, key, overrides);
     } else {
       await deleteUserSetting(ctx.userEmail, key);

package/corpus/templates/content/app/components/editor/DocumentBlockFields.tsx

@@ -1,5 +1,5 @@
 import { useT } from "@agent-native/core/client/i18n";
-import type { DocumentProperty } from "@shared/api";
+import type { DocumentPropertiesResponse, DocumentProperty } from "@shared/api";
 import {
   blocksRenderMode,
   blocksStorageTarget,
@@ -17,9 +17,12 @@ import {
   type PointerEvent as ReactPointerEvent,
 } from "react";
 
-import { useDocumentProperties } from "@/hooks/use-document-properties";
-import { useReorderDocumentProperty } from "@/hooks/use-document-properties";
-import { useSetDocumentProperty } from "@/hooks/use-document-properties";
+import {
+  documentPropertiesResponseMatchesScope,
+  useDocumentProperties,
+  useReorderDocumentProperty,
+  useSetDocumentProperty,
+} from "@/hooks/use-document-properties";
 import { cn } from "@/lib/utils";
 
 import {
@@ -38,6 +41,7 @@ const BLOCK_FIELD_DRAG_THRESHOLD = 6;
 
 interface DocumentBlockFieldsProps {
   documentId: string;
+  databaseId: string;
   databaseDocumentId: string;
   canEdit: boolean;
   /**
@@ -191,17 +195,18 @@ export type BlockFieldsRenderState =
   | { kind: "solo"; field: DocumentProperty; target: BlocksStorageTarget }
   | { kind: "multi"; fields: DocumentProperty[] };
 
-// Whether the query data we are holding actually belongs to the CURRENT row.
+// Whether the query data we are holding belongs to the current row and database.
 // `useDocumentProperties` keeps the previous document's data as placeholder
-// across a documentId change, so identity must be confirmed before the field
+// across a scope change, so both identities must be confirmed before the field
 // layout is trusted — otherwise the old doc's solo-primary layout could route
 // the new doc's edits to the body. The response carries its own `documentId`
 // (shared/api.ts → DocumentPropertiesResponse).
 export function isLoadedForDocument(
   documentId: string,
-  data: { documentId: string } | undefined,
+  databaseId: string,
+  data: DocumentPropertiesResponse | undefined,
 ): boolean {
-  return data?.documentId === documentId;
+  return documentPropertiesResponseMatchesScope(documentId, databaseId, data);
 }
 
 export function blockFieldsRenderState(args: {
@@ -239,28 +244,22 @@ export function blockFieldsRenderState(args: {
  */
 export function DocumentBlockFields({
   documentId,
+  databaseId,
   databaseDocumentId,
   canEdit,
   primaryEditor,
 }: DocumentBlockFieldsProps) {
   const t = useT();
-  const query = useDocumentProperties(documentId);
+  const query = useDocumentProperties(documentId, databaseId);
   const properties = query.data?.properties ?? [];
   const blockFields = useMemo(
     () => blockFieldsFromProperties(properties),
     [properties],
   );
 
-  // Loaded ONLY when the query data we hold actually belongs to the CURRENT
-  // documentId. `useDocumentProperties` uses `placeholderData: (prev) => prev`,
-  // so right after the viewed row changes, `query.data` still holds the PREVIOUS
-  // document's field layout for a tick. Trusting it would let the old doc's
-  // solo-primary layout route the NEW doc's edits to the body (clobbering a
-  // non-primary field). The response carries its own `documentId`
-  // (shared/api.ts → DocumentPropertiesResponse), so we gate on an identity
-  // match: until the data is for THIS document, treat the row as still loading
-  // (a non-editable placeholder), never a writable body editor.
-  const loaded = isLoadedForDocument(documentId, query.data);
+  // Placeholder data may belong to the previous row or database. Trust it only
+  // after both response identities match the active scope.
+  const loaded = isLoadedForDocument(documentId, databaseId, query.data);
   const state = blockFieldsRenderState({ loaded, blockFields });
 
   switch (state.kind) {
@@ -321,6 +320,7 @@ export function DocumentBlockFields({
       return (
         <MultiBlockFields
           documentId={documentId}
+          databaseId={databaseId}
           databaseDocumentId={databaseDocumentId}
           canEdit={canEdit}
           blockFields={state.fields}
@@ -333,6 +333,7 @@ export function DocumentBlockFields({
 
 function MultiBlockFields({
   documentId,
+  databaseId,
   databaseDocumentId,
   canEdit,
   blockFields,
@@ -340,13 +341,18 @@ function MultiBlockFields({
   t,
 }: {
   documentId: string;
+  databaseId: string;
   databaseDocumentId: string;
   canEdit: boolean;
   blockFields: DocumentProperty[];
   primaryEditor: ReactNode;
   t: ReturnType<typeof useT>;
 }) {
-  const reorder = useReorderDocumentProperty(documentId);
+  const reorder = useReorderDocumentProperty(
+    documentId,
+    databaseId,
+    databaseDocumentId,
+  );
   const [dragId, setDragId] = useState<string | null>(null);
   const [dragOverGapIndex, setDragOverGapIndex] = useState<number | null>(null);
   const [dragPreview, setDragPreview] =
@@ -805,7 +811,11 @@ function AdditionalBlockEditor({
   property: DocumentProperty;
   canEdit: boolean;
 }) {
-  const setProperty = useSetDocumentProperty(documentId, databaseDocumentId);
+  const setProperty = useSetDocumentProperty(
+    documentId,
+    property.definition.databaseId!,
+    databaseDocumentId,
+  );
   const propertyId = property.definition.id;
   const initialContent =
     typeof property.value === "string" ? property.value : "";

package/corpus/templates/content/app/components/editor/DocumentEditor.tsx

@@ -109,6 +109,8 @@ const TAB_ID = generateTabId();
 
 interface DocumentEditorProps {
   documentId: string;
+  databaseId?: string | null;
+  databaseDocumentId?: string | null;
 }
 
 type FieldSaveWatermark = { title: string; updatedAt: string | null };
@@ -240,7 +242,11 @@ function DocumentUnavailable({ onOpenHome }: { onOpenHome: () => void }) {
  * only mount once we know the doc exists. Otherwise an invalid id triggers
  * an infinite spinner plus repeating 404/403 polls in the console.
  */
-export function DocumentEditor({ documentId }: DocumentEditorProps) {
+export function DocumentEditor({
+  documentId,
+  databaseId,
+  databaseDocumentId,
+}: DocumentEditorProps) {
   const documentQuery = useDocument(documentId);
   const {
     data: queriedDocument,
@@ -271,7 +277,14 @@ export function DocumentEditor({ documentId }: DocumentEditorProps) {
     return <DocumentEditorSkeleton />;
   }
 
-  return <DocumentEditorBody documentId={documentId} document={document} />;
+  return (
+    <DocumentEditorBody
+      documentId={documentId}
+      document={document}
+      databaseId={databaseId}
+      databaseDocumentId={databaseDocumentId}
+    />
+  );
 }
 
 export function shouldAwaitAuthoritativeDocument({
@@ -287,6 +300,8 @@ export function shouldAwaitAuthoritativeDocument({
 interface DocumentEditorBodyProps {
   documentId: string;
   document: Document;
+  databaseId?: string | null;
+  databaseDocumentId?: string | null;
 }
 
 type PendingDocumentSave = {
@@ -508,7 +523,12 @@ export function documentEditorBreadcrumbNavigationItems(
   return navigationItems;
 }
 
-function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
+function DocumentEditorBody({
+  documentId,
+  document,
+  databaseId,
+  databaseDocumentId,
+}: DocumentEditorBodyProps) {
   const t = useT();
   const updateDocument = useUpdateDocument();
   const createDatabase = useCreateContentDatabase(documentId);
@@ -1674,6 +1694,8 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
       {utilityPanel === "info" ? (
         <DocumentInfoPanel
           document={document}
+          databaseId={databaseId}
+          databaseDocumentId={databaseDocumentId}
           canEdit={editorCanEdit}
           onSaveDescription={(description) =>
             persistDocumentUpdates({ description })
@@ -1970,7 +1992,12 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
                         return (
                           <DocumentBlockFields
                             documentId={documentId}
+                            databaseId={
+                              databaseId ??
+                              document.databaseMembership.databaseId
+                            }
                             databaseDocumentId={
+                              databaseDocumentId ??
                               document.databaseMembership.databaseDocumentId
                             }
                             canEdit={editorCanEdit}

package/corpus/templates/content/app/components/editor/DocumentInfoPanel.tsx

@@ -6,12 +6,16 @@ import { DocumentProperties } from "./DocumentProperties";
 
 interface DocumentInfoPanelProps {
   document: Document;
+  databaseId?: string | null;
+  databaseDocumentId?: string | null;
   canEdit: boolean;
   onSaveDescription: (description: string) => Promise<unknown> | unknown;
 }
 
 export function DocumentInfoPanel({
   document,
+  databaseId,
+  databaseDocumentId,
   canEdit,
   onSaveDescription,
 }: DocumentInfoPanelProps) {
@@ -34,7 +38,10 @@ export function DocumentInfoPanel({
       {document.databaseMembership && !isLocalFileDocument ? (
         <DocumentProperties
           documentId={document.id}
-          databaseDocumentId={document.databaseMembership.databaseDocumentId}
+          databaseId={databaseId ?? document.databaseMembership.databaseId}
+          databaseDocumentId={
+            databaseDocumentId ?? document.databaseMembership.databaseDocumentId
+          }
           canEdit={canEdit}
         />
       ) : null}