@agent-native/core 0.136.4 → 0.137.0

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 {