@agent-native/core 0.95.1 → 0.97.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,
@@ -282,60 +283,75 @@ export default defineAction({
       updates.position =
         normalizedSiblingPositions?.find((document) => document.id === id)
           ?.position ?? args.position;
-    } else if (args.parentId !== undefined) {
-      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),
-          ),
-        );
+    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 (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 (normalizedSiblingPositions) {
-        for (const document of normalizedSiblingPositions) {
-          await tx
-            .update(schema.documents)
-            .set({ position: document.position })
+    if (args.position === undefined && 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;
+      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(() => []);