@agent-native/core 0.136.5 → 0.137.1

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

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, asc, eq, inArray, ne } from "drizzle-orm";
+import { and, asc, eq, inArray, isNull, ne, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -157,41 +157,77 @@ async function clearSourceFederation(sourceId: string, now: string) {
   });
 }
 
-async function removeRowsOwnedOnlyBySource(args: {
+export async function removeRowsOwnedOnlyBySource(args: {
   databaseId: string;
   sourceId: string;
 }) {
   const db = getDb();
-  const [targetRows, otherRows] = await Promise.all([
-    db
-      .select()
-      .from(schema.contentDatabaseSourceRows)
-      .where(eq(schema.contentDatabaseSourceRows.sourceId, args.sourceId)),
-    db
+  await db.transaction(async (tx) => {
+    const [lockedDatabase] = await tx
+      .update(schema.contentDatabases)
+      .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+      .where(
+        and(
+          eq(schema.contentDatabases.id, args.databaseId),
+          isNull(schema.contentDatabases.deletedAt),
+        ),
+      )
+      .returning({ id: schema.contentDatabases.id });
+    if (!lockedDatabase) throw new Error("Database is no longer active.");
+
+    const targetRows = await tx
       .select()
       .from(schema.contentDatabaseSourceRows)
-      .where(ne(schema.contentDatabaseSourceRows.sourceId, args.sourceId)),
-  ]);
-  const otherDocumentIds = new Set(
-    otherRows.map((row) => row.documentId).filter(Boolean),
-  );
-  const itemIds = targetRows
-    .filter(
-      (row) =>
-        row.databaseItemId &&
-        row.documentId &&
-        !otherDocumentIds.has(row.documentId),
-    )
-    .map((row) => row.databaseItemId);
-  if (itemIds.length === 0) return;
-  await db
-    .delete(schema.contentDatabaseItems)
-    .where(
-      and(
-        eq(schema.contentDatabaseItems.databaseId, args.databaseId),
-        inArray(schema.contentDatabaseItems.id, itemIds),
-      ),
+      .where(eq(schema.contentDatabaseSourceRows.sourceId, args.sourceId));
+    const siblingSources = await tx
+      .select({ id: schema.contentDatabaseSources.id })
+      .from(schema.contentDatabaseSources)
+      .where(
+        and(
+          eq(schema.contentDatabaseSources.databaseId, args.databaseId),
+          ne(schema.contentDatabaseSources.id, args.sourceId),
+        ),
+      );
+    const otherRows = siblingSources.length
+      ? await tx
+          .select()
+          .from(schema.contentDatabaseSourceRows)
+          .where(
+            inArray(
+              schema.contentDatabaseSourceRows.sourceId,
+              siblingSources.map((source) => source.id),
+            ),
+          )
+      : [];
+    const otherDocumentIds = new Set(
+      otherRows.map((row) => row.documentId).filter(Boolean),
     );
+    const itemIds = targetRows
+      .filter(
+        (row) =>
+          row.databaseItemId &&
+          row.documentId &&
+          !otherDocumentIds.has(row.documentId),
+      )
+      .map((row) => row.databaseItemId as string);
+    if (itemIds.length === 0) return;
+    await tx
+      .delete(schema.contentDatabaseItemKeyClaims)
+      .where(
+        and(
+          eq(schema.contentDatabaseItemKeyClaims.databaseId, args.databaseId),
+          inArray(schema.contentDatabaseItemKeyClaims.itemId, itemIds),
+        ),
+      );
+    await tx
+      .delete(schema.contentDatabaseItems)
+      .where(
+        and(
+          eq(schema.contentDatabaseItems.databaseId, args.databaseId),
+          inArray(schema.contentDatabaseItems.id, itemIds),
+        ),
+      );
+  });
 }
 
 export async function readBuilderCmsEntriesForRoleChange(

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