@agent-native/core 0.96.0 → 0.98.0

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

@@ -10,6 +10,10 @@ import {
   serializePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import {
+  propertyDefinitionsPositionScope,
+  withPositionLock,
+} from "./_position-utils.js";
 import {
   listPropertiesForDocument,
   nanoid,
@@ -45,21 +49,6 @@ export default defineAction({
       );
     if (!definition) throw new Error(`Property "${propertyId}" not found`);
 
-    const [maxPos] = await db
-      .select({
-        max: sql<number>`COALESCE(MAX(position), -1)`,
-      })
-      .from(schema.documentPropertyDefinitions)
-      .where(
-        and(
-          eq(
-            schema.documentPropertyDefinitions.ownerEmail,
-            document.ownerEmail,
-          ),
-          eq(schema.documentPropertyDefinitions.databaseId, database.id),
-        ),
-      );
-
     const now = new Date().toISOString();
     const newPropertyId = nanoid();
     const isBlocks = isBlocksPropertyType(
@@ -71,19 +60,39 @@ export default defineAction({
       ? serializePropertyOptions({ blocks: { primary: false } })
       : definition.optionsJson;
 
-    await db.insert(schema.documentPropertyDefinitions).values({
-      id: newPropertyId,
-      ownerEmail: definition.ownerEmail,
-      orgId: definition.orgId,
-      databaseId: database.id,
-      name: `${definition.name} copy`,
-      type: definition.type,
-      visibility: definition.visibility,
-      optionsJson,
-      position: (maxPos?.max ?? -1) + 1,
-      createdAt: now,
-      updatedAt: now,
-    });
+    await withPositionLock(
+      propertyDefinitionsPositionScope(database.id),
+      async () => {
+        const [maxPos] = await db
+          .select({
+            max: sql<number>`COALESCE(MAX(position), -1)`,
+          })
+          .from(schema.documentPropertyDefinitions)
+          .where(
+            and(
+              eq(
+                schema.documentPropertyDefinitions.ownerEmail,
+                document.ownerEmail,
+              ),
+              eq(schema.documentPropertyDefinitions.databaseId, database.id),
+            ),
+          );
+
+        await db.insert(schema.documentPropertyDefinitions).values({
+          id: newPropertyId,
+          ownerEmail: definition.ownerEmail,
+          orgId: definition.orgId,
+          databaseId: database.id,
+          name: `${definition.name} copy`,
+          type: definition.type,
+          visibility: definition.visibility,
+          optionsJson,
+          position: (maxPos?.max ?? -1) + 1,
+          createdAt: now,
+          updatedAt: now,
+        });
+      },
+    );
 
     // Blocks fields don't use document_property_values; a duplicate starts empty.
     if (!isBlocks) {

package/corpus/templates/content/actions/list-notion-database-sources.ts

@@ -0,0 +1,80 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { z } from "zod";
+
+import {
+  getNotionConnectionForOwner,
+  notionFetch,
+} from "../server/lib/notion.js";
+import type { NotionDatabaseSourcesResponse } from "../shared/api.js";
+
+function plainText(value: unknown) {
+  return Array.isArray(value)
+    ? value
+        .map((part) =>
+          typeof part === "object" && part && "plain_text" in part
+            ? String((part as { plain_text?: unknown }).plain_text ?? "")
+            : "",
+        )
+        .join("")
+    : "";
+}
+
+export default defineAction({
+  description:
+    "List Notion data sources visible to the current user's connected Notion workspace so one can be attached read-only to a Content database.",
+  schema: z.object({
+    query: z.string().trim().max(200).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    cursor: z.string().trim().min(1).optional(),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args): Promise<NotionDatabaseSourcesResponse> => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail)
+      throw new Error("Notion database access requires a signed-in user.");
+    const connection = await getNotionConnectionForOwner(userEmail);
+    if (!connection) {
+      return {
+        connected: false,
+        workspaceName: null,
+        sources: [],
+        hasMore: false,
+        nextCursor: null,
+      };
+    }
+    const response = await notionFetch<{
+      results?: Array<{
+        object?: string;
+        id: string;
+        url?: string;
+        title?: unknown;
+        name?: string;
+      }>;
+      has_more?: boolean;
+      next_cursor?: string | null;
+    }>("/search", connection.accessToken, {
+      method: "POST",
+      body: JSON.stringify({
+        page_size: args.limit,
+        filter: { property: "object", value: "data_source" },
+        ...(args.query ? { query: args.query } : {}),
+        ...(args.cursor ? { start_cursor: args.cursor } : {}),
+      }),
+    });
+    return {
+      connected: true,
+      workspaceName: connection.workspaceName,
+      sources: (response.results ?? [])
+        .filter((result) => result.object === "data_source")
+        .map((result) => ({
+          id: result.id,
+          name: plainText(result.title) || result.name || "Untitled database",
+          url: result.url ?? null,
+        })),
+      hasMore: response.has_more === true,
+      nextCursor: response.next_cursor ?? null,
+    };
+  },
+});

package/corpus/templates/content/actions/move-document.ts

@@ -14,6 +14,7 @@ import {
   isContentLocalFileMode,
   moveLocalFileDocument,
 } from "./_local-file-documents.js";
+import { documentsPositionScope, withPositionLock } from "./_position-utils.js";
 
 async function assertParentIsNotDescendant({
   db,
@@ -266,76 +267,107 @@ export default defineAction({
             parentId: args.parentId,
           })
         : null;
-    const normalizedSiblingPositions =
-      args.position !== undefined
-        ? await resolveSiblingPositionsAfterMove({
+    let normalizedSiblingPositions: Array<{
+      id: string;
+      position: number;
+    }> | null = null;
+
+    const runMoveTransaction = () =>
+      db.transaction(async (tx) => {
+        await tx
+          .update(schema.documents)
+          .set(updates)
+          .where(
+            and(
+              eq(schema.documents.id, id),
+              eq(schema.documents.ownerEmail, ownerEmail),
+            ),
+          );
+
+        if (args.parentId !== undefined && blockDatabaseIdToDetach) {
+          await clearBlockDatabaseOwnership({
+            db: tx,
+            databaseId: blockDatabaseIdToDetach,
+            ownerEmail,
+            updatedAt,
+          });
+        }
+
+        if (normalizedSiblingPositions) {
+          for (const document of normalizedSiblingPositions) {
+            await tx
+              .update(schema.documents)
+              .set({ position: document.position })
+              .where(
+                and(
+                  eq(schema.documents.id, document.id),
+                  eq(schema.documents.ownerEmail, ownerEmail),
+                ),
+              );
+          }
+        }
+      });
+
+    if (args.position !== undefined) {
+      // Resequencing reads every current sibling under the target parent,
+      // computes a full renumbering with the moved document inserted, then
+      // writes that renumbering. That read-then-write is exactly as racy as
+      // the append path below: two concurrent moves/reparents into the same
+      // parent can each read the same pre-move snapshot and then each commit
+      // a full-but-stale renumbering, silently clobbering the other move or
+      // leaving a document's new position colliding with one a concurrent
+      // append/reparent just claimed. Serialize the read through the write
+      // under the SAME per-(owner, parent) lock the append branch uses so an
+      // append and a reorder/reparent into one parent can't race each other
+      // either (see _position-utils.ts).
+      await withPositionLock(
+        documentsPositionScope(ownerEmail, targetParentId),
+        async () => {
+          normalizedSiblingPositions = await resolveSiblingPositionsAfterMove({
             db,
             ownerEmail,
             id,
             parentId: targetParentId,
             rootSection: existing,
-            position: args.position,
-          })
-        : null;
-
-    if (args.position !== undefined) {
-      updates.position =
-        normalizedSiblingPositions?.find((document) => document.id === id)
-          ?.position ?? args.position;
+            position: args.position!,
+          });
+          updates.position =
+            normalizedSiblingPositions?.find((document) => document.id === id)
+              ?.position ?? args.position;
+          await runMoveTransaction();
+        },
+      );
     } else if (args.parentId !== undefined) {
+      // Appending to the end of the new parent's children reads MAX(position)
+      // then writes MAX+1. Serialize the read through the write so a
+      // concurrent move/create/add targeting the same parent can't read the
+      // same MAX and land on the same position (see _position-utils.ts).
       const parentId = args.parentId;
-      const maxPos = await db
-        .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-        .from(schema.documents)
-        .where(
-          parentId
-            ? and(
-                eq(schema.documents.ownerEmail, ownerEmail),
-                eq(schema.documents.parentId, parentId),
-              )
-            : and(
-                eq(schema.documents.ownerEmail, ownerEmail),
-                rootSectionFilter(existing),
-                sql`parent_id IS NULL`,
-              ),
-        );
-      updates.position = (maxPos[0]?.max ?? -1) + 1;
-    }
-
-    await db.transaction(async (tx) => {
-      await tx
-        .update(schema.documents)
-        .set(updates)
-        .where(
-          and(
-            eq(schema.documents.id, id),
-            eq(schema.documents.ownerEmail, ownerEmail),
-          ),
-        );
-
-      if (args.parentId !== undefined && blockDatabaseIdToDetach) {
-        await clearBlockDatabaseOwnership({
-          db: tx,
-          databaseId: blockDatabaseIdToDetach,
-          ownerEmail,
-          updatedAt,
-        });
-      }
-
-      if (normalizedSiblingPositions) {
-        for (const document of normalizedSiblingPositions) {
-          await tx
-            .update(schema.documents)
-            .set({ position: document.position })
+      await withPositionLock(
+        documentsPositionScope(ownerEmail, parentId),
+        async () => {
+          const maxPos = await db
+            .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+            .from(schema.documents)
             .where(
-              and(
-                eq(schema.documents.id, document.id),
-                eq(schema.documents.ownerEmail, ownerEmail),
-              ),
+              parentId
+                ? and(
+                    eq(schema.documents.ownerEmail, ownerEmail),
+                    eq(schema.documents.parentId, parentId),
+                  )
+                : and(
+                    eq(schema.documents.ownerEmail, ownerEmail),
+                    rootSectionFilter(existing),
+                    sql`parent_id IS NULL`,
+                  ),
             );
-        }
-      }
-    });
+          updates.position = (maxPos[0]?.max ?? -1) + 1;
+          await runMoveTransaction();
+        },
+      );
+    } else {
+      await runMoveTransaction();
+    }
 
     const [doc] = await db
       .select()

package/corpus/templates/content/actions/refresh-content-database-source.ts

@@ -3,6 +3,7 @@ import { assertAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
 import type { ContentDatabaseSourceStatusResponse } from "../shared/api.js";
+import { getContentDatabaseSourceAdapter } from "./_content-database-source-adapters.js";
 import {
   getContentDatabaseSourceSnapshot,
   getContentDatabaseSourceSnapshotById,
@@ -10,12 +11,15 @@ import {
   resyncBuilderCmsSourceSnapshot,
   resyncMockSourceSnapshot,
   resolveDatabaseForSourceMutation,
+  seedSecondarySourceFields,
+  storeSecondarySourceRows,
+  updateReadOnlySourceMetadata,
 } from "./_database-source-utils.js";
 import { serializeDatabase } from "./_property-utils.js";
 
 export default defineAction({
   description:
-    "Refresh the local read-only source status envelope for a content database. Mock-local and Builder CMS fixture sources resync field mappings and row identity without provider writes. For Builder CMS sources, set fullRefresh to true when you need to read every available page in one action call instead of continuing one partial page.",
+    "Refresh the local read-only source status envelope for a content database. Mock-local, Builder CMS, and Notion database sources resync field mappings and row identity without provider writes. For paginated Builder CMS or Notion sources, set fullRefresh to true to read a bounded multi-page snapshot in one action call.",
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
@@ -27,7 +31,7 @@ export default defineAction({
       .boolean()
       .optional()
       .describe(
-        "For Builder CMS sources, read all available pages in this refresh instead of one continuation page.",
+        "For paginated Builder CMS or Notion sources, read a bounded multi-page snapshot in this refresh.",
       ),
   }),
   run: async (args): Promise<ContentDatabaseSourceStatusResponse> => {
@@ -58,6 +62,39 @@ export default defineAction({
     } else if (source.sourceType === "local-table") {
       // Read-only federated secondary; its rows are re-read on demand, nothing
       // to resync against the primary's local snapshot here.
+    } else if (source.sourceType === "notion-database") {
+      const adapter = getContentDatabaseSourceAdapter("notion-database");
+      const read = await adapter!.read({
+        sourceTable: source.sourceTable,
+        limit: 500,
+        offset: 0,
+        fullRefresh: args.fullRefresh === true,
+      });
+      await storeSecondarySourceRows({
+        sourceId: source.id,
+        ownerEmail: database.ownerEmail,
+        sourceType: "notion-database",
+        sourceTable: source.sourceTable,
+        entries: read.entries,
+        now,
+      });
+      await seedSecondarySourceFields({
+        sourceId: source.id,
+        ownerEmail: database.ownerEmail,
+        sourceType: "notion-database",
+        modelFields: read.fields,
+        sampleEntry: read.entries[0],
+        now,
+      });
+      await updateReadOnlySourceMetadata({
+        sourceId: source.id,
+        sourceType: "notion-database",
+        sourceTable: source.sourceTable,
+        fetchedAt: read.fetchedAt,
+        now,
+        message: read.message,
+        metadata: read.metadata,
+      });
     } else {
       throw new Error(`Unsupported source type "${source.sourceType}".`);
     }
@@ -81,7 +118,9 @@ export default defineAction({
       summary: snapshot
         ? builderFetching
           ? `${snapshot.sourceName} fetched ${builderFetched ?? "some"} rows. Run refresh again to continue loading the remaining Builder rows.`
-          : `${snapshot.sourceName} resynced locally; field mappings and row identity now reflect the current database snapshot.`
+          : snapshot.sourceType === "notion-database"
+            ? `${snapshot.sourceName} refreshed read-only from Notion.`
+            : `${snapshot.sourceName} resynced locally; field mappings and row identity now reflect the current database snapshot.`
         : "Source metadata refreshed.",
       source: snapshot,
     };

package/corpus/templates/content/actions/share-local-file-document.ts

@@ -19,6 +19,7 @@ import {
   isLocalFileDocumentId,
   localDocumentPathFromId,
 } from "./_local-file-documents.js";
+import { documentsPositionScope, withPositionLock } from "./_position-utils.js";
 
 function nanoid(size = 12): string {
   const chars =
@@ -123,34 +124,42 @@ export default defineAction({
       return serializeDocument(row);
     }
 
-    const [{ max: maxPosition } = { max: -1 }] = await db
-      .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-      .from(schema.documents)
-      .where(
-        and(eq(schema.documents.ownerEmail, userEmail), sql`parent_id IS NULL`),
-      );
-
     const documentId = nanoid();
-    await db.insert(schema.documents).values({
-      id: documentId,
-      ownerEmail: userEmail,
-      orgId,
-      parentId: null,
-      title: localDocument.title,
-      content: localDocument.content,
-      icon: localDocument.icon,
-      position: (maxPosition ?? -1) + 1,
-      isFavorite: localDocument.isFavorite ? 1 : 0,
-      hideFromSearch: localDocument.hideFromSearch ? 1 : 0,
-      visibility: "private",
-      sourceMode: "database",
-      sourceKind: "local-file-copy",
-      sourcePath,
-      sourceRootPath: localDocument.source?.rootPath ?? null,
-      sourceUpdatedAt: localDocument.source?.updatedAt ?? now,
-      createdAt: now,
-      updatedAt: now,
-    });
+    await withPositionLock(
+      documentsPositionScope(userEmail, null),
+      async () => {
+        const [{ max: maxPosition } = { max: -1 }] = await db
+          .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+          .from(schema.documents)
+          .where(
+            and(
+              eq(schema.documents.ownerEmail, userEmail),
+              sql`parent_id IS NULL`,
+            ),
+          );
+
+        await db.insert(schema.documents).values({
+          id: documentId,
+          ownerEmail: userEmail,
+          orgId,
+          parentId: null,
+          title: localDocument.title,
+          content: localDocument.content,
+          icon: localDocument.icon,
+          position: (maxPosition ?? -1) + 1,
+          isFavorite: localDocument.isFavorite ? 1 : 0,
+          hideFromSearch: localDocument.hideFromSearch ? 1 : 0,
+          visibility: "private",
+          sourceMode: "database",
+          sourceKind: "local-file-copy",
+          sourcePath,
+          sourceRootPath: localDocument.source?.rootPath ?? null,
+          sourceUpdatedAt: localDocument.source?.updatedAt ?? now,
+          createdAt: now,
+          updatedAt: now,
+        });
+      },
+    );
 
     const [row] = await db
       .select()

package/corpus/templates/content/actions/suggest-source-join-key.ts

@@ -10,10 +10,12 @@ import {
   readBuilderCmsContentEntries,
   readBuilderCmsModelFields,
 } from "./_builder-cms-read-client.js";
+import { getContentDatabaseSourceAdapter } from "./_content-database-source-adapters.js";
 import {
   getContentDatabaseSourceSnapshot,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
 import { suggestJoinKey } from "./_join-suggestion.js";
 import { readLocalTableEntries } from "./_local-table-source.js";
 
@@ -23,7 +25,12 @@ export default defineAction({
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
-    candidateSourceType: z.enum(["mock-local", "builder-cms", "local-table"]),
+    candidateSourceType: z.enum([
+      "mock-local",
+      "builder-cms",
+      "local-table",
+      "notion-database",
+    ]),
     candidateSourceTable: z
       .string()
       .describe("Model/table name of the source being added."),
@@ -38,23 +45,39 @@ export default defineAction({
     if (!access) throw new Error(`Database "${database.id}" not found`);
 
     const primary = await getContentDatabaseSourceSnapshot(database);
-    if (!primary) {
-      return {
-        state: "no-primary",
-        suggestion: null,
-        message: "Attach a first source before federating a second one.",
-      };
-    }
-
-    const primaryValues = primary.rows
-      .map((row) => row.sourceValues)
-      .filter((values): values is Record<string, DocumentPropertyValue> =>
-        Boolean(values),
-      )
-      .slice(0, args.sampleLimit);
+    const primaryValues = primary
+      ? primary.rows
+          .map((row) => row.sourceValues)
+          .filter((values): values is Record<string, DocumentPropertyValue> =>
+            Boolean(values),
+          )
+          .slice(0, args.sampleLimit)
+      : (
+          await getContentDatabaseResponse(database.id, {
+            limit: args.sampleLimit,
+            offset: 0,
+          })
+        ).items.map((item) => ({
+          title: item.document.title ?? "",
+          ...Object.fromEntries(
+            item.properties
+              .filter((property) => !!property.definition.id)
+              .map((property) => [property.definition.id, property.value]),
+          ),
+        }));
 
     let secondaryValues: Record<string, DocumentPropertyValue>[];
-    if (args.candidateSourceType === "builder-cms") {
+    if (args.candidateSourceType === "notion-database") {
+      const adapter = getContentDatabaseSourceAdapter(args.candidateSourceType);
+      const read = await adapter!.read({
+        sourceTable: args.candidateSourceTable,
+        limit: args.sampleLimit,
+        offset: 0,
+      });
+      secondaryValues = read.entries
+        .map((entry) => entry.sourceValues)
+        .slice(0, args.sampleLimit);
+    } else if (args.candidateSourceType === "builder-cms") {
       const modelFields = await readBuilderCmsModelFields({
         model: args.candidateSourceTable,
       }).catch(() => []);

package/corpus/templates/content/app/components/QueryErrorState.tsx

@@ -0,0 +1,39 @@
+import { useT } from "@agent-native/core/client";
+import { IconAlertTriangle } from "@tabler/icons-react";
+
+import { Button } from "@/components/ui/button";
+
+export function QueryErrorState({
+  onRetry,
+  retrying = false,
+  compact = false,
+}: {
+  onRetry: () => void;
+  retrying?: boolean;
+  compact?: boolean;
+}) {
+  const t = useT();
+
+  return (
+    <div
+      className={
+        compact
+          ? "flex flex-col items-center gap-2 px-3 py-4 text-center"
+          : "flex flex-1 items-center justify-center bg-background px-6"
+      }
+    >
+      <div className="flex max-w-sm flex-col items-center gap-3 text-center">
+        <IconAlertTriangle className="size-7 text-destructive" />
+        <p className="text-sm text-destructive">{t("empty.genericError")}</p>
+        <Button
+          size="sm"
+          variant="outline"
+          onClick={onRetry}
+          disabled={retrying}
+        >
+          {t("database.retry")}
+        </Button>
+      </div>
+    </div>
+  );
+}

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

@@ -164,7 +164,7 @@ export function LinkHoverPreview({
         left: Math.max(16, hoveredLink.rect.left),
         zIndex: 50,
       }}
-      className="w-72 rounded-lg border bg-popover text-popover-foreground shadow-md overflow-hidden animate-in fade-in-0 zoom-in-95"
+      className="w-72 rounded-lg border bg-popover text-popover-foreground shadow-md overflow-hidden animate-in fade-in-0 zoom-in-95 origin-top-left"
     >
       {editing ? (
         <div className="flex items-center gap-1 p-1.5">