@agent-native/core 0.136.5 → 0.137.1

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() });

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

@@ -88,6 +88,33 @@ export default defineAction({
       .where(eq(schema.documentShares.resourceId, row.database.documentId));
 
     await db.transaction(async (tx) => {
+      const [lockedDatabase] = await tx
+        .update(schema.contentDatabases)
+        .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+        .where(
+          and(
+            eq(schema.contentDatabases.id, row.database.id),
+            eq(schema.contentDatabases.ownerEmail, row.database.ownerEmail),
+            isNull(schema.contentDatabases.deletedAt),
+          ),
+        )
+        .returning({ id: schema.contentDatabases.id });
+      if (!lockedDatabase) throw new Error("Database is no longer active.");
+      const [claimedSource] = await tx
+        .select({ id: schema.contentDatabaseItemKeyClaims.id })
+        .from(schema.contentDatabaseItemKeyClaims)
+        .where(
+          and(
+            eq(schema.contentDatabaseItemKeyClaims.databaseId, row.database.id),
+            eq(schema.contentDatabaseItemKeyClaims.documentId, row.document.id),
+          ),
+        )
+        .limit(1);
+      if (claimedSource) {
+        throw new Error(
+          "Rows with active stable-key claims cannot be duplicated.",
+        );
+      }
       await tx
         .update(schema.contentDatabaseItems)
         .set({

package/corpus/templates/content/actions/duplicate-database-items.ts

@@ -2,7 +2,7 @@ import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, gte, inArray, sql } from "drizzle-orm";
+import { and, eq, gte, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
 import { ensureDocumentsFilesMembership } from "./_content-files.js";
@@ -86,6 +86,36 @@ export default defineAction({
     }));
 
     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.ownerEmail, database.ownerEmail),
+            isNull(schema.contentDatabases.deletedAt),
+          ),
+        )
+        .returning({ id: schema.contentDatabases.id });
+      if (!lockedDatabase) throw new Error("Database is no longer active.");
+      const [claimedSource] = await tx
+        .select({ id: schema.contentDatabaseItemKeyClaims.id })
+        .from(schema.contentDatabaseItemKeyClaims)
+        .where(
+          and(
+            eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+            inArray(
+              schema.contentDatabaseItemKeyClaims.documentId,
+              sourceDocumentIds,
+            ),
+          ),
+        )
+        .limit(1);
+      if (claimedSource) {
+        throw new Error(
+          "Rows with active stable-key claims cannot be duplicated.",
+        );
+      }
       await tx
         .update(schema.contentDatabaseItems)
         .set({

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

@@ -15,12 +15,10 @@ export default defineAction({
   run: async ({ id }) => {
     const access = await assertAccess("document", id, "admin");
     const db = getDb();
-    const deleted = await db.transaction((tx) =>
-      deleteTrashedDocumentSubtree(
-        tx as unknown as ReturnType<typeof getDb>,
-        id,
-        access.resource.ownerEmail as string,
-      ),
+    const deleted = await deleteTrashedDocumentSubtree(
+      db,
+      id,
+      access.resource.ownerEmail as string,
     );
     await writeAppState("refresh-signal", { ts: Date.now() });
     return { success: true, deleted: deleted.length };

package/corpus/templates/content/actions/remove-database-items.ts

@@ -145,6 +145,19 @@ export default defineAction({
               ),
             );
         }
+        if (removedItemIds.length > 0) {
+          await tx
+            .delete(schema.contentDatabaseItemKeyClaims)
+            .where(
+              and(
+                eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+                inArray(
+                  schema.contentDatabaseItemKeyClaims.itemId,
+                  removedItemIds,
+                ),
+              ),
+            );
+        }
         if (removedItemIds.length > 0) {
           await tx
             .delete(schema.contentDatabaseItems)

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

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, isNull, ne, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -130,7 +130,65 @@ export default defineAction({
 
     const valueJson = normalizedValueJson(type, value);
     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, database.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.databaseId, database.id),
+            eq(
+              schema.documentPropertyDefinitions.ownerEmail,
+              database.ownerEmail,
+            ),
+          ),
+        )
+        .returning({
+          type: schema.documentPropertyDefinitions.type,
+          systemRole: schema.documentPropertyDefinitions.systemRole,
+        });
+      if (
+        !lockedDefinition ||
+        lockedDefinition.type !== definition.type ||
+        lockedDefinition.systemRole
+      ) {
+        throw new Error(
+          `Property "${propertyId}" changed or was deleted before its value could be written.`,
+        );
+      }
       await lockDatabaseMemberships(tx, [membership.id]);
+      const [conflictingClaim] = await tx
+        .select({ id: schema.contentDatabaseItemKeyClaims.id })
+        .from(schema.contentDatabaseItemKeyClaims)
+        .where(
+          and(
+            eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+            eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+            eq(schema.contentDatabaseItemKeyClaims.keyValueJson, valueJson),
+            ne(schema.contentDatabaseItemKeyClaims.documentId, documentId),
+          ),
+        )
+        .limit(1);
+      if (conflictingClaim) {
+        throw new Error(
+          "This value is already claimed as another row's stable key.",
+        );
+      }
       const [existing] = await tx
         .select({ id: schema.documentPropertyValues.id })
         .from(schema.documentPropertyValues)
@@ -156,6 +214,16 @@ export default defineAction({
           updatedAt: now,
         });
       }
+      await tx
+        .delete(schema.contentDatabaseItemKeyClaims)
+        .where(
+          and(
+            eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+            eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+            eq(schema.contentDatabaseItemKeyClaims.documentId, documentId),
+            ne(schema.contentDatabaseItemKeyClaims.keyValueJson, valueJson),
+          ),
+        );
     });
 
     return {