@agent-native/core 0.96.0 → 0.97.0

package/corpus/templates/content/actions/_property-utils.ts

@@ -42,6 +42,10 @@ import {
   type DocumentPropertyValue,
 } from "../shared/properties.js";
 import { chunks } from "./_batch-utils.js";
+import {
+  propertyDefinitionsPositionScope,
+  withPositionLock,
+} from "./_position-utils.js";
 
 type DocumentRow = InferSelectModel<typeof schema.documents>;
 type ContentDatabaseRow = InferSelectModel<typeof schema.contentDatabases>;
@@ -1116,27 +1120,34 @@ export async function seedDefaultBlocksField(args: {
   if (database.primaryId) return database.primaryId;
   if (database.blocksSeeded === 1) return null;
 
-  const [maxPos] = await db
-    .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-    .from(schema.documentPropertyDefinitions)
-    .where(eq(schema.documentPropertyDefinitions.databaseId, args.databaseId));
+  await withPositionLock(
+    propertyDefinitionsPositionScope(args.databaseId),
+    async () => {
+      const [maxPos] = await db
+        .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+        .from(schema.documentPropertyDefinitions)
+        .where(
+          eq(schema.documentPropertyDefinitions.databaseId, args.databaseId),
+        );
 
-  await db
-    .insert(schema.documentPropertyDefinitions)
-    .values({
-      id,
-      ownerEmail: args.ownerEmail,
-      orgId: args.orgId,
-      databaseId: args.databaseId,
-      name: DEFAULT_BLOCKS_FIELD_NAME,
-      type: "blocks",
-      visibility: "always_show",
-      optionsJson: serializePropertyOptions({ blocks: { primary: true } }),
-      position: (maxPos?.max ?? -1) + 1,
-      createdAt: args.now,
-      updatedAt: args.now,
-    })
-    .onConflictDoNothing();
+      await db
+        .insert(schema.documentPropertyDefinitions)
+        .values({
+          id,
+          ownerEmail: args.ownerEmail,
+          orgId: args.orgId,
+          databaseId: args.databaseId,
+          name: DEFAULT_BLOCKS_FIELD_NAME,
+          type: "blocks",
+          visibility: "always_show",
+          optionsJson: serializePropertyOptions({ blocks: { primary: true } }),
+          position: (maxPos?.max ?? -1) + 1,
+          createdAt: args.now,
+          updatedAt: args.now,
+        })
+        .onConflictDoNothing();
+    },
+  );
 
   const claim = await db
     .update(schema.contentDatabases)

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

@@ -11,6 +11,11 @@ import {
   type DocumentPropertyType,
 } from "../shared/properties.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
+import {
+  databaseItemsPositionScope,
+  documentsPositionScope,
+  withPositionLock,
+} from "./_position-utils.js";
 import { nanoid, normalizedValueJson } from "./_property-utils.js";
 
 export default defineAction({
@@ -44,48 +49,56 @@ export default defineAction({
     const databaseDocument = access.resource;
     const now = new Date().toISOString();
 
-    const [maxDocPos] = await db
-      .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-      .from(schema.documents)
-      .where(
-        and(
-          eq(schema.documents.ownerEmail, database.ownerEmail),
-          eq(schema.documents.parentId, database.documentId),
-        ),
-      );
-
-    const [maxItemPos] = await db
-      .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-      .from(schema.contentDatabaseItems)
-      .where(eq(schema.contentDatabaseItems.databaseId, databaseId));
-
     const documentId = nanoid();
     const itemId = nanoid();
-    await db.insert(schema.documents).values({
-      id: documentId,
-      ownerEmail: database.ownerEmail,
-      orgId: database.orgId,
-      parentId: database.documentId,
-      title: title?.trim() ?? "",
-      content: "",
-      icon: null,
-      position: (maxDocPos?.max ?? -1) + 1,
-      isFavorite: 0,
-      hideFromSearch: databaseDocument.hideFromSearch ?? 0,
-      visibility: databaseDocument.visibility ?? "private",
-      createdAt: now,
-      updatedAt: now,
-    });
 
-    await db.insert(schema.contentDatabaseItems).values({
-      id: itemId,
-      ownerEmail: database.ownerEmail,
-      orgId: database.orgId,
-      databaseId,
-      documentId,
-      position: (maxItemPos?.max ?? -1) + 1,
-      createdAt: now,
-      updatedAt: now,
+    await withPositionLock(
+      documentsPositionScope(database.ownerEmail, database.documentId),
+      async () => {
+        const [maxDocPos] = await db
+          .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+          .from(schema.documents)
+          .where(
+            and(
+              eq(schema.documents.ownerEmail, database.ownerEmail),
+              eq(schema.documents.parentId, database.documentId),
+            ),
+          );
+
+        await db.insert(schema.documents).values({
+          id: documentId,
+          ownerEmail: database.ownerEmail,
+          orgId: database.orgId,
+          parentId: database.documentId,
+          title: title?.trim() ?? "",
+          content: "",
+          icon: null,
+          position: (maxDocPos?.max ?? -1) + 1,
+          isFavorite: 0,
+          hideFromSearch: databaseDocument.hideFromSearch ?? 0,
+          visibility: databaseDocument.visibility ?? "private",
+          createdAt: now,
+          updatedAt: now,
+        });
+      },
+    );
+
+    await withPositionLock(databaseItemsPositionScope(databaseId), async () => {
+      const [maxItemPos] = await db
+        .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+        .from(schema.contentDatabaseItems)
+        .where(eq(schema.contentDatabaseItems.databaseId, databaseId));
+
+      await db.insert(schema.contentDatabaseItems).values({
+        id: itemId,
+        ownerEmail: database.ownerEmail,
+        orgId: database.orgId,
+        databaseId,
+        documentId,
+        position: (maxItemPos?.max ?? -1) + 1,
+        createdAt: now,
+        updatedAt: now,
+      });
     });
 
     const inheritedShares = await db

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

@@ -15,6 +15,7 @@ import {
   type BuilderCmsReadResult,
 } from "./_builder-cms-read-client.js";
 import type { BuilderCmsSourceEntry } from "./_builder-cms-source-adapter.js";
+import { getContentDatabaseSourceAdapter } from "./_content-database-source-adapters.js";
 import {
   databaseSourceExistsForTable,
   enqueueBuilderBodyHydrationForItems,
@@ -32,6 +33,7 @@ import {
   sourceSetupPayload,
   storeSecondarySourceRows,
   updateBuilderCmsSourceReadMetadata,
+  updateReadOnlySourceMetadata,
   writeSourceFederation,
 } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
@@ -41,7 +43,7 @@ import {
 } from "./_local-table-source.js";
 
 const sourceTypeSchema = z
-  .enum(["mock-local", "builder-cms", "local-table"])
+  .enum(["mock-local", "builder-cms", "local-table", "notion-database"])
   .default("mock-local");
 const BUILDER_CMS_ATTACH_INITIAL_PAGES = 1;
 
@@ -237,14 +239,23 @@ export default defineAction({
     const now = new Date().toISOString();
     const sourceType = (args.sourceType ??
       "mock-local") as ContentDatabaseSourceType;
+    if (sourceType === "notion-database" && !args.sourceTable?.trim()) {
+      throw new Error(
+        "sourceTable must be a Notion data-source ID returned by list-notion-database-sources.",
+      );
+    }
     const sourceName =
       args.sourceName?.trim() ||
-      (sourceType === "builder-cms" ? "Builder CMS" : "Mock local source");
+      (sourceType === "builder-cms"
+        ? "Builder CMS"
+        : sourceType === "notion-database"
+          ? "Notion database"
+          : "Mock local source");
     const sourceTable =
       args.sourceTable?.trim() ||
       (sourceType === "builder-cms" ? "blog_article" : "content_items");
 
-    const existingSource = await getExistingSource(database.id);
+    let existingSource = await getExistingSource(database.id);
     if (sourceType === "local-table") {
       if (sourceTable === database.id) {
         throw new Error("A database can't be added as a source of itself.");
@@ -255,6 +266,41 @@ export default defineAction({
     const relationshipMode =
       args.relationshipMode ?? (args.mode === "add" ? "items" : undefined);
 
+    // A normal local Content database has rows but no explicit source record.
+    // Bootstrap that local snapshot before attaching a read-only details source
+    // so Notion federation works without forcing users to attach Builder first.
+    if (
+      sourceType === "notion-database" &&
+      relationshipMode === "details" &&
+      !existingSource
+    ) {
+      const setup = await sourceSetupPayload(database.id);
+      const localSourceId = await replaceSourceMetadata({
+        database,
+        source: null,
+        sourceType: "mock-local",
+        sourceName: "Local Content database",
+        sourceTable: database.id,
+        now,
+      });
+      await seedMockSourceFields({
+        sourceId: localSourceId,
+        ownerEmail: database.ownerEmail,
+        sourceType: "mock-local",
+        properties: setup.properties,
+        now,
+      });
+      await seedMockSourceRows({
+        sourceId: localSourceId,
+        ownerEmail: database.ownerEmail,
+        sourceType: "mock-local",
+        sourceTable: database.id,
+        items: setup.response.items,
+        now,
+      });
+      existingSource = await getExistingSource(database.id);
+    }
+
     // Adding a SECOND source as details: relate it onto the primary on the
     // canonical key. Read-only overlay — the secondary's entries are NOT
     // imported as local documents/items.
@@ -265,17 +311,35 @@ export default defineAction({
       let entries: BuilderCmsSourceEntry[];
       let modelFields: BuilderCmsModelFieldSummary[];
       let builderRead: BuilderCmsReadResult | null = null;
-      if (sourceType === "builder-cms") {
+      let adapterMetadata: Record<string, unknown> | undefined;
+      let adapterFetchedAt = now;
+      let adapterMessage: string | null = null;
+      const adapter = getContentDatabaseSourceAdapter(sourceType);
+      if (adapter) {
+        const read = await adapter.read({
+          sourceTable,
+          limit: args.limit,
+          offset: args.offset,
+        });
+        entries = read.state === "live" ? read.entries : [];
+        modelFields = read.fields;
+        adapterMetadata = read.metadata;
+        adapterFetchedAt = read.fetchedAt;
+        adapterMessage = read.message;
+        if (sourceType === "builder-cms") {
+          builderRead = {
+            state: read.state,
+            entries: read.entries,
+            fetchedAt: read.fetchedAt,
+            message: read.message,
+            progress: read.progress!,
+          };
+        }
+      } else if (sourceType === "builder-cms") {
         const initial = await readInitialBuilderCmsAttachSource(sourceTable);
         modelFields = initial.modelFields;
         builderRead = initial.read;
         entries = builderRead.state === "live" ? builderRead.entries : [];
-      } else if (sourceType === "local-table") {
-        // sourceTable carries the target database id for a local-table source.
-        ({ entries, modelFields } = await readLocalTableEntries(sourceTable, {
-          limit: args.limit,
-          offset: args.offset,
-        }));
       } else {
         entries = [];
         modelFields = [];
@@ -299,6 +363,7 @@ export default defineAction({
       await seedSecondarySourceFields({
         sourceId: secondaryId,
         ownerEmail: database.ownerEmail,
+        sourceType,
         modelFields,
         sampleEntry: entries[0],
         now,
@@ -317,6 +382,17 @@ export default defineAction({
           ...builderCmsAttachReadMetadata(builderRead),
         });
       }
+      if (sourceType === "notion-database") {
+        await updateReadOnlySourceMetadata({
+          sourceId: secondaryId,
+          sourceType,
+          sourceTable,
+          fetchedAt: adapterFetchedAt,
+          now,
+          message: adapterMessage,
+          metadata: adapterMetadata,
+        });
+      }
       await writeSourceFederation({
         sourceId: secondaryId,
         federation: identityFederation(
@@ -458,7 +534,15 @@ export default defineAction({
     }
 
     if (relationshipMode === "items" && existingSource) {
-      throw new Error("Only Builder sources can add more items right now.");
+      throw new Error(
+        "Only Builder sources can add more items right now. Notion database sources are read-only detail sources in this pilot.",
+      );
+    }
+
+    if (sourceType === "notion-database") {
+      throw new Error(
+        "Notion database sources are read-only detail sources in this pilot. Attach a local or Builder source first, then add Notion details with a match key.",
+      );
     }
 
     const existingSourceRows = existingSource

package/corpus/templates/content/actions/change-content-database-source-role.ts

@@ -16,6 +16,7 @@ import {
   readBuilderCmsModelFields,
 } from "./_builder-cms-read-client.js";
 import type { BuilderCmsSourceEntry } from "./_builder-cms-source-adapter.js";
+import { getContentDatabaseSourceAdapter } from "./_content-database-source-adapters.js";
 import {
   enqueueBuilderBodyHydrationForItems,
   ensureDatabaseSourceProperty,
@@ -109,7 +110,12 @@ function identityFederation(
 }
 
 function sourceType(value: string): ContentDatabaseSourceType {
-  if (value === "builder-cms" || value === "local-table") return value;
+  if (
+    value === "builder-cms" ||
+    value === "local-table" ||
+    value === "notion-database"
+  )
+    return value;
   return "mock-local";
 }
 
@@ -255,6 +261,22 @@ async function readSourceEntries(args: {
       message: null,
     };
   }
+  if (args.sourceType === "notion-database") {
+    const read = await getContentDatabaseSourceAdapter("notion-database")!.read(
+      {
+        sourceTable: args.sourceTable,
+        limit: args.limit,
+        offset: args.offset,
+      },
+    );
+    return {
+      entries: read.entries,
+      modelFields: read.fields,
+      readState: read.state,
+      fetchedAt: read.fetchedAt,
+      message: read.message,
+    };
+  }
   return {
     entries: [],
     modelFields: [],
@@ -330,6 +352,7 @@ export default defineAction({
       await seedSecondarySourceFields({
         sourceId: source.id,
         ownerEmail: database.ownerEmail,
+        sourceType: normalizedType,
         modelFields,
         sampleEntry: entries[0],
         now,

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

@@ -16,6 +16,10 @@ import {
   normalizePropertyVisibility,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import {
+  propertyDefinitionsPositionScope,
+  withPositionLock,
+} from "./_position-utils.js";
 import {
   listPropertiesForDocument,
   nanoid,
@@ -168,34 +172,39 @@ export default defineAction({
         })
         .where(eq(schema.documentPropertyDefinitions.id, args.id));
     } else {
-      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 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: nanoid(),
-        ownerEmail: document.ownerEmail,
-        orgId: document.orgId ?? null,
-        databaseId: database.id,
-        name,
-        type,
-        visibility: normalizePropertyVisibility(args.visibility),
-        optionsJson,
-        position: (maxPos?.max ?? -1) + 1,
-        createdAt: now,
-        updatedAt: now,
-      });
+          await db.insert(schema.documentPropertyDefinitions).values({
+            id: nanoid(),
+            ownerEmail: document.ownerEmail,
+            orgId: document.orgId ?? null,
+            databaseId: database.id,
+            name,
+            type,
+            visibility: normalizePropertyVisibility(args.visibility),
+            optionsJson,
+            position: (maxPos?.max ?? -1) + 1,
+            createdAt: now,
+            updatedAt: now,
+          });
+        },
+      );
     }
 
     await writeAppState("refresh-signal", { ts: Date.now() });

package/corpus/templates/content/actions/create-content-database.ts

@@ -15,6 +15,7 @@ import type {
   CreateDatabaseRequest,
 } from "../shared/api.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
+import { documentsPositionScope, withPositionLock } from "./_position-utils.js";
 import { nanoid, seedDefaultBlocksField } from "./_property-utils.js";
 
 const createContentDatabaseSchema = z.object({
@@ -132,37 +133,46 @@ export async function createContentDatabaseRecord(
         .where(eq(schema.documentShares.resourceId, 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),
-              sql`parent_id IS NULL`,
-            ),
-      );
-
     documentId = nanoid();
-    await db.insert(schema.documents).values({
-      id: documentId,
-      ownerEmail,
-      orgId,
-      parentId,
-      title,
-      content: "",
-      icon: null,
-      position: (maxPos?.max ?? -1) + 1,
-      isFavorite: 0,
-      hideFromSearch,
-      visibility,
-      createdAt: now,
-      updatedAt: now,
-    });
+    // Snapshot as a const so the closure below keeps TypeScript's
+    // non-undefined narrowing from the guard above (`let` bindings lose
+    // narrowing across a closure boundary).
+    const resolvedOwnerEmail = ownerEmail;
+    await withPositionLock(
+      documentsPositionScope(resolvedOwnerEmail, parentId),
+      async () => {
+        const [maxPos] = await db
+          .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+          .from(schema.documents)
+          .where(
+            parentId
+              ? and(
+                  eq(schema.documents.ownerEmail, resolvedOwnerEmail),
+                  eq(schema.documents.parentId, parentId),
+                )
+              : and(
+                  eq(schema.documents.ownerEmail, resolvedOwnerEmail),
+                  sql`parent_id IS NULL`,
+                ),
+          );
+
+        await db.insert(schema.documents).values({
+          id: documentId!,
+          ownerEmail: resolvedOwnerEmail,
+          orgId,
+          parentId,
+          title,
+          content: "",
+          icon: null,
+          position: (maxPos?.max ?? -1) + 1,
+          isFavorite: 0,
+          hideFromSearch,
+          visibility,
+          createdAt: now,
+          updatedAt: now,
+        });
+      },
+    );
 
     if (inheritedShares.length > 0) {
       await db.insert(schema.documentShares).values(

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

@@ -18,6 +18,7 @@ import {
   createLocalFileDocument,
   isContentLocalFileMode,
 } from "./_local-file-documents.js";
+import { documentsPositionScope, withPositionLock } from "./_position-utils.js";
 
 function nanoid(size = 12): string {
   const chars =
@@ -122,41 +123,47 @@ export default defineAction({
         .where(eq(schema.documentShares.resourceId, parentId));
     }
 
-    // Get max position among siblings
-    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),
-              sql`parent_id IS NULL`,
-            ),
-      );
-
-    const position = (maxPos[0]?.max ?? -1) + 1;
     const now = new Date().toISOString();
     const id = args.id || nanoid();
 
-    await db.insert(schema.documents).values({
-      id,
-      ownerEmail,
-      orgId,
-      parentId,
-      title,
-      content,
-      icon,
-      position,
-      isFavorite: 0,
-      hideFromSearch,
-      visibility,
-      createdAt: now,
-      updatedAt: now,
-    });
+    await withPositionLock(
+      documentsPositionScope(ownerEmail, parentId),
+      async () => {
+        // Get max position among siblings
+        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),
+                  sql`parent_id IS NULL`,
+                ),
+          );
+
+        const position = (maxPos[0]?.max ?? -1) + 1;
+
+        await db.insert(schema.documents).values({
+          id,
+          ownerEmail,
+          orgId,
+          parentId,
+          title,
+          content,
+          icon,
+          position,
+          isFavorite: 0,
+          hideFromSearch,
+          visibility,
+          createdAt: now,
+          updatedAt: now,
+        });
+      },
+    );
 
     if (inheritedShares.length > 0) {
       await db.insert(schema.documentShares).values(