@agent-native/core 0.136.4 → 0.137.0

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

@@ -1,7 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, sql } from "drizzle-orm";
+import { and, eq, isNull, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -114,12 +114,13 @@ export default defineAction({
     }
 
     if (args.id) {
+      const propertyId = args.id;
       const [existing] = await db
         .select()
         .from(schema.documentPropertyDefinitions)
         .where(
           and(
-            eq(schema.documentPropertyDefinitions.id, args.id),
+            eq(schema.documentPropertyDefinitions.id, propertyId),
             eq(
               schema.documentPropertyDefinitions.ownerEmail,
               document.ownerEmail,
@@ -127,7 +128,7 @@ export default defineAction({
             eq(schema.documentPropertyDefinitions.databaseId, database.id),
           ),
         );
-      if (!existing) throw new Error(`Property "${args.id}" not found`);
+      if (!existing) throw new Error(`Property "${propertyId}" not found`);
       if (existing.systemRole) {
         throw new Error("System properties cannot be changed.");
       }
@@ -158,42 +159,122 @@ export default defineAction({
         optionsJson = serializePropertyOptions({ blocks: { primary: true } });
       }
 
-      if (existing.type !== type) {
-        await db
-          .delete(schema.documentPropertyValues)
+      await db.transaction(async (tx) => {
+        const [lockedDatabase] = await tx
+          .update(schema.contentDatabases)
+          .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
           .where(
             and(
-              eq(schema.documentPropertyValues.propertyId, args.id),
-              eq(schema.documentPropertyValues.ownerEmail, document.ownerEmail),
+              eq(schema.contentDatabases.id, database.id),
+              eq(schema.contentDatabases.documentId, database.documentId),
+              eq(schema.contentDatabases.ownerEmail, document.ownerEmail),
+              isNull(schema.contentDatabases.deletedAt),
             ),
-          );
-        // Switching a Blocks field to another type drops its independent content.
+          )
+          .returning({ id: schema.contentDatabases.id });
+        if (!lockedDatabase) throw new Error("Database is no longer active.");
+        const [lockedExisting] = await tx
+          .update(schema.documentPropertyDefinitions)
+          .set({
+            updatedAt: sql`${schema.documentPropertyDefinitions.updatedAt}`,
+          })
+          .where(
+            and(
+              eq(schema.documentPropertyDefinitions.id, propertyId),
+              eq(
+                schema.documentPropertyDefinitions.ownerEmail,
+                document.ownerEmail,
+              ),
+              eq(schema.documentPropertyDefinitions.databaseId, database.id),
+            ),
+          )
+          .returning();
+        if (!lockedExisting)
+          throw new Error(`Property "${propertyId}" not found`);
+        if (lockedExisting.systemRole)
+          throw new Error("System properties cannot be changed.");
         if (
-          isBlocksPropertyType(existing.type as DocumentPropertyType) &&
-          !isBlocksPropertyType(type)
+          isComputedPropertyType(lockedExisting.type as DocumentPropertyType) &&
+          lockedExisting.type !== type
         ) {
-          await db
-            .delete(schema.documentBlockFieldContents)
-            .where(eq(schema.documentBlockFieldContents.propertyId, args.id));
+          throw new Error("Computed property types cannot be changed.");
+        }
+        const lockedIsPrimaryBlocks =
+          isBlocksPropertyType(lockedExisting.type as DocumentPropertyType) &&
+          isPrimaryBlocksField(
+            parsePropertyOptions(lockedExisting.optionsJson),
+          );
+        if (lockedIsPrimaryBlocks && lockedExisting.type !== type) {
+          throw new Error(
+            "The primary Content (Blocks) field cannot change type. Delete it from the database view to remove the body.",
+          );
         }
-      }
 
-      await db
-        .update(schema.documentPropertyDefinitions)
-        .set({
-          name,
-          ...(args.description === undefined
-            ? {}
-            : { description: args.description.trim() }),
-          type,
-          visibility:
-            args.visibility === undefined
-              ? normalizePropertyVisibility(existing.visibility)
-              : normalizePropertyVisibility(args.visibility),
-          optionsJson,
-          updatedAt: now,
-        })
-        .where(eq(schema.documentPropertyDefinitions.id, args.id));
+        if (lockedExisting.type !== type) {
+          const [mappedSourceField] = await tx
+            .select({ id: schema.contentDatabaseSourceFields.id })
+            .from(schema.contentDatabaseSourceFields)
+            .where(
+              eq(schema.contentDatabaseSourceFields.propertyId, propertyId),
+            )
+            .limit(1);
+          if (mappedSourceField) {
+            throw new Error(
+              "A property bound to a source field must be unbound before changing its type.",
+            );
+          }
+          await tx
+            .delete(schema.documentPropertyValues)
+            .where(
+              and(
+                eq(schema.documentPropertyValues.propertyId, propertyId),
+                eq(
+                  schema.documentPropertyValues.ownerEmail,
+                  document.ownerEmail,
+                ),
+              ),
+            );
+          await tx
+            .delete(schema.contentDatabaseItemKeyClaims)
+            .where(
+              and(
+                eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+                eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+              ),
+            );
+          // Switching a Blocks field to another type drops its independent content.
+          if (
+            isBlocksPropertyType(lockedExisting.type as DocumentPropertyType) &&
+            !isBlocksPropertyType(type)
+          ) {
+            await tx
+              .delete(schema.documentBlockFieldContents)
+              .where(
+                eq(schema.documentBlockFieldContents.propertyId, propertyId),
+              );
+          }
+        }
+
+        await tx
+          .update(schema.documentPropertyDefinitions)
+          .set({
+            name,
+            ...(args.description === undefined
+              ? {}
+              : { description: args.description.trim() }),
+            type,
+            visibility:
+              args.visibility === undefined
+                ? normalizePropertyVisibility(lockedExisting.visibility)
+                : normalizePropertyVisibility(args.visibility),
+            optionsJson:
+              lockedIsPrimaryBlocks && isBlocksPropertyType(type)
+                ? serializePropertyOptions({ blocks: { primary: true } })
+                : optionsJson,
+            updatedAt: now,
+          })
+          .where(eq(schema.documentPropertyDefinitions.id, propertyId));
+      });
     } else {
       await withPositionLock(
         propertyDefinitionsPositionScope(database.id),

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

@@ -21,13 +21,11 @@ export default defineAction({
     await assertAccess("document", database.documentId, "admin");
     const db = getDb();
     const deletedAt = database.deletedAt ?? new Date().toISOString();
-    await db.transaction((tx) =>
-      trashDocumentSubtree(
-        tx as unknown as ReturnType<typeof getDb>,
-        database.documentId,
-        database.ownerEmail,
-        deletedAt,
-      ),
+    await trashDocumentSubtree(
+      db,
+      database.documentId,
+      database.ownerEmail,
+      deletedAt,
     );
 
     await writeAppState("refresh-signal", { ts: Date.now() });

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

@@ -1,7 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, inArray } from "drizzle-orm";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -65,74 +65,121 @@ export default defineAction({
       isBlocks &&
       isPrimaryBlocksField(parsePropertyOptions(definition.optionsJson));
 
-    await db
-      .delete(schema.documentPropertyValues)
-      .where(eq(schema.documentPropertyValues.propertyId, propertyId));
-    await db
-      .delete(schema.documentPropertyDefinitions)
-      .where(eq(schema.documentPropertyDefinitions.id, propertyId));
+    await db.transaction(async (tx) => {
+      const [lockedDatabase] = await tx
+        .update(schema.contentDatabases)
+        .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+        .where(
+          and(
+            eq(schema.contentDatabases.id, database.id),
+            eq(schema.contentDatabases.documentId, database.documentId),
+            eq(schema.contentDatabases.ownerEmail, document.ownerEmail),
+            isNull(schema.contentDatabases.deletedAt),
+          ),
+        )
+        .returning({ id: schema.contentDatabases.id });
+      if (!lockedDatabase) throw new Error("Database is no longer active.");
+      const [lockedDefinition] = await tx
+        .update(schema.documentPropertyDefinitions)
+        .set({
+          updatedAt: sql`${schema.documentPropertyDefinitions.updatedAt}`,
+        })
+        .where(
+          and(
+            eq(schema.documentPropertyDefinitions.id, propertyId),
+            eq(
+              schema.documentPropertyDefinitions.ownerEmail,
+              document.ownerEmail,
+            ),
+            eq(schema.documentPropertyDefinitions.databaseId, database.id),
+          ),
+        )
+        .returning({
+          id: schema.documentPropertyDefinitions.id,
+          systemRole: schema.documentPropertyDefinitions.systemRole,
+        });
+      if (!lockedDefinition)
+        throw new Error(`Property "${propertyId}" not found`);
+      if (lockedDefinition.systemRole)
+        throw new Error("System properties cannot be deleted.");
+
+      await tx
+        .delete(schema.documentPropertyValues)
+        .where(eq(schema.documentPropertyValues.propertyId, propertyId));
+      await tx
+        .delete(schema.contentDatabaseItemKeyClaims)
+        .where(
+          and(
+            eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+            eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+          ),
+        );
+      await tx
+        .delete(schema.documentPropertyDefinitions)
+        .where(eq(schema.documentPropertyDefinitions.id, propertyId));
 
-    if (isBlocks) {
-      // Drop the independent content for this Blocks field across every row.
-      await db
-        .delete(schema.documentBlockFieldContents)
-        .where(eq(schema.documentBlockFieldContents.propertyId, propertyId));
+      if (isBlocks) {
+        // Drop the independent content for this Blocks field across every row.
+        await tx
+          .delete(schema.documentBlockFieldContents)
+          .where(eq(schema.documentBlockFieldContents.propertyId, propertyId));
 
-      // Deleting the primary "Content" field removes the body (documents.content)
-      // for every object of this type, per the delete warning shown in the UI.
-      if (isPrimaryBlocks) {
-        // Record that the primary was intentionally removed: clear the single
-        // source of truth but LEAVE blocks_seeded = 1, so neither the read path
-        // nor the startup repair ever recreates it. Deleting the only Blocks
-        // field is an allowed product action that leaves the row metadata-only
-        // with ZERO Blocks fields.
-        await db
-          .update(schema.contentDatabases)
-          .set({
-            primaryBlocksPropertyId: null,
-            updatedAt: new Date().toISOString(),
-          })
-          .where(eq(schema.contentDatabases.id, database.id));
+        // Deleting the primary "Content" field removes the body (documents.content)
+        // for every object of this type, per the delete warning shown in the UI.
+        if (isPrimaryBlocks) {
+          // Record that the primary was intentionally removed: clear the single
+          // source of truth but LEAVE blocks_seeded = 1, so neither the read path
+          // nor the startup repair ever recreates it. Deleting the only Blocks
+          // field is an allowed product action that leaves the row metadata-only
+          // with ZERO Blocks fields.
+          await tx
+            .update(schema.contentDatabases)
+            .set({
+              primaryBlocksPropertyId: null,
+              updatedAt: new Date().toISOString(),
+            })
+            .where(eq(schema.contentDatabases.id, database.id));
 
-        const items = await db
-          .select({ documentId: schema.contentDatabaseItems.documentId })
-          .from(schema.contentDatabaseItems)
-          .where(eq(schema.contentDatabaseItems.databaseId, database.id));
-        const documentIds = items.map((item) => item.documentId);
-        if (documentIds.length > 0) {
-          const now = new Date().toISOString();
-          await db
-            .update(schema.documents)
-            .set({ content: "", updatedAt: now })
-            .where(inArray(schema.documents.id, documentIds));
+          const items = await tx
+            .select({ documentId: schema.contentDatabaseItems.documentId })
+            .from(schema.contentDatabaseItems)
+            .where(eq(schema.contentDatabaseItems.databaseId, database.id));
+          const documentIds = items.map((item) => item.documentId);
+          if (documentIds.length > 0) {
+            const now = new Date().toISOString();
+            await tx
+              .update(schema.documents)
+              .set({ content: "", updatedAt: now })
+              .where(inArray(schema.documents.id, documentIds));
+          }
         }
       }
-    }
 
-    // Free any source field that was mapped to this property so it returns to
-    // the "From source" picker immediately, instead of staying orphaned until
-    // the next source refresh reconciles it.
-    const mappedFields = await db
-      .select({
-        id: schema.contentDatabaseSourceFields.id,
-        sourceFieldKey: schema.contentDatabaseSourceFields.sourceFieldKey,
-      })
-      .from(schema.contentDatabaseSourceFields)
-      .where(eq(schema.contentDatabaseSourceFields.propertyId, propertyId));
-    if (mappedFields.length > 0) {
-      const now = new Date().toISOString();
-      for (const mapped of mappedFields) {
-        await db
-          .update(schema.contentDatabaseSourceFields)
-          .set({
-            propertyId: null,
-            localFieldKey: mapped.sourceFieldKey,
-            mappingType: "property",
-            updatedAt: now,
-          })
-          .where(eq(schema.contentDatabaseSourceFields.id, mapped.id));
+      // Free any source field that was mapped to this property so it returns to
+      // the "From source" picker immediately, instead of staying orphaned until
+      // the next source refresh reconciles it.
+      const mappedFields = await tx
+        .select({
+          id: schema.contentDatabaseSourceFields.id,
+          sourceFieldKey: schema.contentDatabaseSourceFields.sourceFieldKey,
+        })
+        .from(schema.contentDatabaseSourceFields)
+        .where(eq(schema.contentDatabaseSourceFields.propertyId, propertyId));
+      if (mappedFields.length > 0) {
+        const now = new Date().toISOString();
+        for (const mapped of mappedFields) {
+          await tx
+            .update(schema.contentDatabaseSourceFields)
+            .set({
+              propertyId: null,
+              localFieldKey: mapped.sourceFieldKey,
+              mappingType: "property",
+              updatedAt: now,
+            })
+            .where(eq(schema.contentDatabaseSourceFields.id, mapped.id));
+        }
       }
-    }
+    });
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 

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

@@ -1,7 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, inArray, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { and, eq, inArray, isNotNull, isNull, ne, or, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -97,6 +97,28 @@ async function selectDatabaseItemDocuments(
   return ownedRows.map((row) => ({ documentId: row.id }));
 }
 
+async function selectMembershipDatabaseIds(
+  db: ReturnType<typeof getDb>,
+  documentIds: string[],
+  ownerEmail: string,
+) {
+  const rows: Array<{ databaseId: string }> = [];
+  for (const batch of chunks(documentIds, DELETE_BATCH_SIZE)) {
+    rows.push(
+      ...(await db
+        .select({ databaseId: schema.contentDatabaseItems.databaseId })
+        .from(schema.contentDatabaseItems)
+        .where(
+          and(
+            inArray(schema.contentDatabaseItems.documentId, batch),
+            eq(schema.contentDatabaseItems.ownerEmail, ownerEmail),
+          ),
+        )),
+    );
+  }
+  return [...new Set(rows.map((row) => row.databaseId))];
+}
+
 async function collectDocumentSubtreeForDelete(
   db: ReturnType<typeof getDb>,
   rootId: string,
@@ -150,22 +172,83 @@ async function collectDocumentSubtreeForDelete(
     frontier = [...next];
   }
 
+  const collectedDocumentIds = [...documentIds];
+  const collectedOwnedDatabaseIds = [...ownedDatabaseIds];
   return {
-    documentIds: [...documentIds],
-    ownedDatabaseIds: [...ownedDatabaseIds],
+    documentIds: collectedDocumentIds,
+    ownedDatabaseIds: collectedOwnedDatabaseIds,
+    lockDatabaseIds: [
+      ...new Set([
+        ...collectedOwnedDatabaseIds,
+        ...(await selectMembershipDatabaseIds(
+          db,
+          collectedDocumentIds,
+          ownerEmail,
+        )),
+      ]),
+    ],
   };
 }
 
+async function lockDatabasesAndRecollect<
+  T extends { lockDatabaseIds: string[] },
+>(
+  db: ReturnType<typeof getDb>,
+  ownerEmail: string,
+  collect: () => Promise<T>,
+): Promise<T> {
+  const lockedDatabaseIds = new Set<string>();
+  let collected = await collect();
+  while (true) {
+    const unlockedDatabaseIds = collected.lockDatabaseIds.filter(
+      (databaseId) => !lockedDatabaseIds.has(databaseId),
+    );
+    if (unlockedDatabaseIds.length === 0) return collected;
+    for (const batch of chunks(unlockedDatabaseIds, DELETE_BATCH_SIZE)) {
+      await db
+        .update(schema.contentDatabases)
+        .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+        .where(
+          and(
+            inArray(schema.contentDatabases.id, batch),
+            eq(schema.contentDatabases.ownerEmail, ownerEmail),
+          ),
+        );
+      for (const databaseId of batch) lockedDatabaseIds.add(databaseId);
+    }
+    collected = await collect();
+  }
+}
+
 export async function trashDocumentSubtree(
   db: ReturnType<typeof getDb>,
   id: string,
   ownerEmail: string,
   trashedAt = new Date().toISOString(),
 ): Promise<string[]> {
-  const { documentIds } = await collectDocumentSubtreeForDelete(
-    db,
-    id,
-    ownerEmail,
+  return db.transaction((tx) =>
+    trashDocumentSubtreeInTransaction(
+      tx as unknown as ReturnType<typeof getDb>,
+      id,
+      ownerEmail,
+      trashedAt,
+    ),
+  );
+}
+
+async function trashDocumentSubtreeInTransaction(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  ownerEmail: string,
+  trashedAt: string,
+): Promise<string[]> {
+  // Stable-key upserts lock their canonical database row before creating or
+  // updating children. Acquire the same locks, then collect again: an upsert
+  // that won the lock before this transaction may have added a child after the
+  // first traversal, while one that arrives later must wait until the database
+  // has been marked deleted and will fail closed.
+  const { documentIds } = await lockDatabasesAndRecollect(db, ownerEmail, () =>
+    collectDocumentSubtreeForDelete(db, id, ownerEmail),
   );
   await assertNotWorkspaceCatalogDocuments(db, documentIds, "deleted");
 
@@ -316,14 +399,20 @@ export async function deleteDocumentRecursive(
   id: string,
   ownerEmail: string,
 ): Promise<string[]> {
-  const { documentIds, ownedDatabaseIds } =
-    await collectDocumentSubtreeForDelete(db, id, ownerEmail);
-  return deleteCollectedDocuments(
-    db,
-    documentIds,
-    ownedDatabaseIds,
-    ownerEmail,
-  );
+  return db.transaction(async (tx) => {
+    const scopedDb = tx as unknown as ReturnType<typeof getDb>;
+    const { documentIds, ownedDatabaseIds } = await lockDatabasesAndRecollect(
+      scopedDb,
+      ownerEmail,
+      () => collectDocumentSubtreeForDelete(scopedDb, id, ownerEmail),
+    );
+    return deleteCollectedDocuments(
+      scopedDb,
+      documentIds,
+      ownedDatabaseIds,
+      ownerEmail,
+    );
+  });
 }
 
 async function deleteCollectedDocuments(
@@ -416,6 +505,27 @@ async function deleteCollectedDocuments(
       );
   });
 
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseItemKeyClaims)
+      .where(
+        inArray(
+          schema.contentDatabaseItemKeyClaims.databaseId,
+          databaseIdBatch,
+        ),
+      );
+  });
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseItemKeyClaims)
+      .where(
+        inArray(
+          schema.contentDatabaseItemKeyClaims.documentId,
+          documentIdBatch,
+        ),
+      );
+  });
+
   await deleteWhereIn(documentIds, async (documentIdBatch) => {
     await db
       .delete(schema.contentDatabaseBodyHydrationQueue)
@@ -518,6 +628,20 @@ export async function deleteTrashedDocumentSubtree(
   db: ReturnType<typeof getDb>,
   id: string,
   ownerEmail: string,
+): Promise<string[]> {
+  return db.transaction((tx) =>
+    deleteTrashedDocumentSubtreeInTransaction(
+      tx as unknown as ReturnType<typeof getDb>,
+      id,
+      ownerEmail,
+    ),
+  );
+}
+
+async function deleteTrashedDocumentSubtreeInTransaction(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  ownerEmail: string,
 ): Promise<string[]> {
   const [root] = await db
     .select({ id: schema.documents.id })
@@ -537,23 +661,43 @@ export async function deleteTrashedDocumentSubtree(
     );
   }
 
-  const documentIds = (
-    await db
-      .select({ id: schema.documents.id })
-      .from(schema.documents)
-      .where(
-        and(
-          eq(schema.documents.ownerEmail, ownerEmail),
-          eq(schema.documents.trashRootId, id),
-          isNotNull(schema.documents.trashedAt),
-        ),
-      )
-  ).map((document) => document.id);
-  const ownedDatabaseIds = await selectOwnedDatabaseIds(
+  const { documentIds, ownedDatabaseIds } = await lockDatabasesAndRecollect(
     db,
-    documentIds,
     ownerEmail,
-  ).then((rows) => rows.map((database) => database.id));
+    async () => {
+      const collectedDocumentIds = (
+        await db
+          .select({ id: schema.documents.id })
+          .from(schema.documents)
+          .where(
+            and(
+              eq(schema.documents.ownerEmail, ownerEmail),
+              eq(schema.documents.trashRootId, id),
+              isNotNull(schema.documents.trashedAt),
+            ),
+          )
+      ).map((document) => document.id);
+      const collectedDatabaseIds = await selectOwnedDatabaseIds(
+        db,
+        collectedDocumentIds,
+        ownerEmail,
+      ).then((rows) => rows.map((database) => database.id));
+      return {
+        documentIds: collectedDocumentIds,
+        ownedDatabaseIds: collectedDatabaseIds,
+        lockDatabaseIds: [
+          ...new Set([
+            ...collectedDatabaseIds,
+            ...(await selectMembershipDatabaseIds(
+              db,
+              collectedDocumentIds,
+              ownerEmail,
+            )),
+          ]),
+        ],
+      };
+    },
+  );
 
   await db
     .update(schema.documents)
@@ -633,12 +777,10 @@ export default defineAction({
     if (systemDatabase?.systemRole) {
       throw new Error("System Content database documents cannot be deleted");
     }
-    const deleted = await db.transaction((tx) =>
-      trashDocumentSubtree(
-        tx as unknown as ReturnType<typeof getDb>,
-        id,
-        existing.ownerEmail as string,
-      ),
+    const deleted = await trashDocumentSubtree(
+      db,
+      id,
+      existing.ownerEmail as string,
     );
 
     await writeAppState("refresh-signal", { ts: Date.now() });