@agent-native/core 0.134.0 → 0.134.1

package/corpus/templates/content/actions/add-content-database-source-field-property.ts

@@ -28,6 +28,7 @@ import {
   builderCmsQualifiedId,
   type BuilderCmsSourceEntry,
 } from "./_builder-cms-source-adapter.js";
+import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
   resolveDatabaseForSourceMutation,
   serializeSourceField,
@@ -460,6 +461,11 @@ export default defineAction({
           documentId: string;
           sourceValuesJson: string | null;
         }> = [];
+        const sourceRowUpdates: Array<{
+          id: string;
+          previousSourceValuesJson: string;
+          sourceValuesJson: string;
+        }> = [];
         if (builderEntries) {
           const currentSourceRows = await tx
             .select()
@@ -487,27 +493,11 @@ export default defineAction({
             ) {
               continue;
             }
-            const [updatedRow] = await tx
-              .update(schema.contentDatabaseSourceRows)
-              .set({
-                sourceValuesJson: mergedRow.sourceValuesJson,
-                updatedAt: now,
-              })
-              .where(
-                and(
-                  eq(schema.contentDatabaseSourceRows.id, currentRow.id),
-                  eq(
-                    schema.contentDatabaseSourceRows.sourceValuesJson,
-                    currentRow.sourceValuesJson,
-                  ),
-                ),
-              )
-              .returning({ id: schema.contentDatabaseSourceRows.id });
-            if (!updatedRow) {
-              throw new Error(
-                "The Builder source changed while adding this property. No property was created; try again.",
-              );
-            }
+            sourceRowUpdates.push({
+              id: currentRow.id,
+              previousSourceValuesJson: currentRow.sourceValuesJson,
+              sourceValuesJson: mergedRow.sourceValuesJson,
+            });
           }
           sourceRows = merged.rows;
         } else if (!isSecondary) {
@@ -545,6 +535,34 @@ export default defineAction({
           );
         }
 
+        await lockDatabaseMemberships(
+          tx,
+          sourceRows.map((row) => row.databaseItemId),
+        );
+        for (const update of sourceRowUpdates) {
+          const [updatedRow] = await tx
+            .update(schema.contentDatabaseSourceRows)
+            .set({
+              sourceValuesJson: update.sourceValuesJson,
+              updatedAt: now,
+            })
+            .where(
+              and(
+                eq(schema.contentDatabaseSourceRows.id, update.id),
+                eq(
+                  schema.contentDatabaseSourceRows.sourceValuesJson,
+                  update.previousSourceValuesJson,
+                ),
+              ),
+            )
+            .returning({ id: schema.contentDatabaseSourceRows.id });
+          if (!updatedRow) {
+            throw new Error(
+              "The Builder source changed while adding this property. No property was created; try again.",
+            );
+          }
+        }
+
         const builderMetadata = builderMetadataForSourceField({
           sourceFieldKey: currentField.sourceFieldKey,
           sourceMetadataJson: currentSource.metadataJson,

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

@@ -27,6 +27,7 @@ import {
   importBuilderCmsEntriesAsDatabaseItems,
   insertSecondarySource,
   mapBuilderCmsEntriesToLocalItems,
+  replaceMockSourceRows,
   replaceSourceMetadata,
   resolveDatabaseForSourceMutation,
   seedMockSourceFields,
@@ -511,6 +512,7 @@ export default defineAction({
       if (additionalRead.state === "live") {
         const importResult = await importBuilderCmsEntriesAsDatabaseItems({
           database,
+          sourceId: additionalSourceId,
           entries: additionalEntries,
           now,
           sourceTable,
@@ -634,6 +636,7 @@ export default defineAction({
     if (builderRead?.state === "live") {
       const importResult = await importBuilderCmsEntriesAsDatabaseItems({
         database,
+        sourceId,
         entries: builderEntries,
         now,
         sourceTable,
@@ -682,7 +685,7 @@ export default defineAction({
         builderSampleEntries: builderEntries,
         now,
       });
-      await seedMockSourceRows({
+      await replaceMockSourceRows({
         sourceId,
         ownerEmail: database.ownerEmail,
         sourceType,

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

@@ -23,9 +23,9 @@ import {
   importBuilderCmsEntriesAsDatabaseItems,
   mapBuilderCmsEntriesToLocalItems,
   mutateContentDatabaseSourceMetadata,
+  replaceMockSourceRows,
   resolveDatabaseForSourceMutation,
   seedMockSourceFields,
-  seedMockSourceRows,
   seedSecondarySourceFields,
   sourceSetupPayload,
   storeSecondarySourceRows,
@@ -400,9 +400,6 @@ export default defineAction({
       await db
         .delete(schema.contentDatabaseSourceFields)
         .where(eq(schema.contentDatabaseSourceFields.sourceId, source.id));
-      await db
-        .delete(schema.contentDatabaseSourceRows)
-        .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
       await clearSourceFederation(source.id, now);
 
       let importedEntriesByDocumentId = new Map<
@@ -412,6 +409,7 @@ export default defineAction({
       if (read.state === "live") {
         const importResult = await importBuilderCmsEntriesAsDatabaseItems({
           database,
+          sourceId: source.id,
           entries,
           now,
           sourceTable: source.sourceTable,
@@ -443,7 +441,7 @@ export default defineAction({
         builderSampleEntries: entries,
         now,
       });
-      await seedMockSourceRows({
+      await replaceMockSourceRows({
         sourceId: source.id,
         ownerEmail: database.ownerEmail,
         sourceType: "builder-cms",

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

@@ -10,6 +10,7 @@ import {
   serializePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
   propertyDefinitionsPositionScope,
   withPositionLock,
@@ -76,57 +77,69 @@ export default defineAction({
     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.transaction(async (tx) => {
+          const memberships = await tx
+            .select({ id: schema.contentDatabaseItems.id })
+            .from(schema.contentDatabaseItems)
+            .where(eq(schema.contentDatabaseItems.databaseId, database.id));
+          await lockDatabaseMemberships(
+            tx,
+            memberships.map((membership) => membership.id),
           );
 
-        await db.insert(schema.documentPropertyDefinitions).values({
-          id: newPropertyId,
-          ownerEmail: definition.ownerEmail,
-          orgId: definition.orgId,
-          databaseId: database.id,
-          name: `${definition.name} copy`,
-          type: definition.type,
-          visibility: definition.visibility,
-          optionsJson,
-          position: (maxPos?.max ?? -1) + 1,
-          createdAt: now,
-          updatedAt: now,
-        });
-      },
-    );
+          const [maxPos] = await tx
+            .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),
+              ),
+            );
 
-    // Blocks fields don't use document_property_values; a duplicate starts empty.
-    if (!isBlocks) {
-      const values = await db
-        .select()
-        .from(schema.documentPropertyValues)
-        .where(eq(schema.documentPropertyValues.propertyId, propertyId));
-      if (values.length > 0) {
-        await db.insert(schema.documentPropertyValues).values(
-          values.map((value) => ({
-            id: nanoid(),
-            ownerEmail: value.ownerEmail,
-            documentId: value.documentId,
-            propertyId: newPropertyId,
-            valueJson: value.valueJson,
+          await tx.insert(schema.documentPropertyDefinitions).values({
+            id: newPropertyId,
+            ownerEmail: definition.ownerEmail,
+            orgId: definition.orgId,
+            databaseId: database.id,
+            name: `${definition.name} copy`,
+            type: definition.type,
+            visibility: definition.visibility,
+            optionsJson,
+            position: (maxPos?.max ?? -1) + 1,
             createdAt: now,
             updatedAt: now,
-          })),
-        );
-      }
-    }
+          });
+
+          // Blocks fields don't use document_property_values; a duplicate
+          // starts empty.
+          if (!isBlocks) {
+            const values = await tx
+              .select()
+              .from(schema.documentPropertyValues)
+              .where(eq(schema.documentPropertyValues.propertyId, propertyId));
+            if (values.length > 0) {
+              await tx.insert(schema.documentPropertyValues).values(
+                values.map((value) => ({
+                  id: nanoid(),
+                  ownerEmail: value.ownerEmail,
+                  documentId: value.documentId,
+                  propertyId: newPropertyId,
+                  valueJson: value.valueJson,
+                  createdAt: now,
+                  updatedAt: now,
+                })),
+              );
+            }
+          }
+        });
+      },
+    );
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 

package/corpus/templates/content/actions/execute-builder-source-execution.ts

@@ -44,6 +44,7 @@ import {
   executeBuilderCmsWrite,
 } from "./_builder-cms-write-client.js";
 import { createBuilderSourceTiming } from "./_builder-source-timings.js";
+import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
   getContentDatabaseSourceSnapshotForWrite,
   resolveDatabaseForSourceMutation,
@@ -563,80 +564,85 @@ async function reconcileBuilderCmsWrite(args: {
   }
 
   const db = getDb();
-  const existingRow =
-    args.changeSet.documentId || args.changeSet.databaseItemId
-      ? await db
-          .select()
-          .from(schema.contentDatabaseSourceRows)
-          .where(
-            and(
-              eq(schema.contentDatabaseSourceRows.sourceId, args.source.id),
-              args.changeSet.documentId
-                ? eq(
-                    schema.contentDatabaseSourceRows.documentId,
-                    args.changeSet.documentId,
-                  )
-                : eq(
-                    schema.contentDatabaseSourceRows.databaseItemId,
-                    args.changeSet.databaseItemId as string,
-                  ),
-            ),
-          )
-          .limit(1)
-      : [];
+  await db.transaction(async (tx) => {
+    if (args.changeSet.databaseItemId) {
+      await lockDatabaseMemberships(tx, [args.changeSet.databaseItemId]);
+    }
+    const existingRow =
+      args.changeSet.documentId || args.changeSet.databaseItemId
+        ? await tx
+            .select()
+            .from(schema.contentDatabaseSourceRows)
+            .where(
+              and(
+                eq(schema.contentDatabaseSourceRows.sourceId, args.source.id),
+                args.changeSet.documentId
+                  ? eq(
+                      schema.contentDatabaseSourceRows.documentId,
+                      args.changeSet.documentId,
+                    )
+                  : eq(
+                      schema.contentDatabaseSourceRows.databaseItemId,
+                      args.changeSet.databaseItemId as string,
+                    ),
+              ),
+            )
+            .limit(1)
+        : [];
 
-  const [row] = existingRow;
-  const snapshotRow = sourceRowForChangeSet(args.source, args.changeSet);
-  const sourceValuesJson = builderCmsReconciledSourceValuesJson({
-    existingSourceValuesJson: row?.sourceValuesJson,
-    snapshotSourceValues: snapshotRow?.sourceValues,
-    changeSet: args.changeSet,
-    plan: args.plan,
-  });
-  const patchWithValues = {
-    ...patch,
-    sourceValuesJson,
-  };
-  if (row) {
-    await db
-      .update(schema.contentDatabaseSourceRows)
-      .set(patchWithValues)
-      .where(eq(schema.contentDatabaseSourceRows.id, row.id));
-  } else if (args.changeSet.documentId && args.changeSet.databaseItemId) {
-    await db.insert(schema.contentDatabaseSourceRows).values({
-      id: crypto.randomUUID(),
-      ownerEmail: args.database.ownerEmail,
-      sourceId: args.source.id,
-      databaseItemId: args.changeSet.databaseItemId,
-      documentId: args.changeSet.documentId,
-      createdAt: args.now,
-      ...patchWithValues,
+    const [row] = existingRow;
+    const snapshotRow = sourceRowForChangeSet(args.source, args.changeSet);
+    const sourceValuesJson = builderCmsReconciledSourceValuesJson({
+      existingSourceValuesJson: row?.sourceValuesJson,
+      snapshotSourceValues: snapshotRow?.sourceValues,
+      changeSet: args.changeSet,
+      plan: args.plan,
     });
-  } else {
-    throw new Error(
-      "Builder write succeeded, but the local source row was missing.",
-    );
-  }
+    const patchWithValues = {
+      ...patch,
+      sourceValuesJson,
+    };
+    if (row) {
+      await tx
+        .update(schema.contentDatabaseSourceRows)
+        .set(patchWithValues)
+        .where(eq(schema.contentDatabaseSourceRows.id, row.id));
+    } else if (args.changeSet.documentId && args.changeSet.databaseItemId) {
+      await tx.insert(schema.contentDatabaseSourceRows).values({
+        id: crypto.randomUUID(),
+        ownerEmail: args.database.ownerEmail,
+        sourceId: args.source.id,
+        databaseItemId: args.changeSet.databaseItemId,
+        documentId: args.changeSet.documentId,
+        createdAt: args.now,
+        ...patchWithValues,
+      });
+    } else {
+      throw new Error(
+        "Builder write succeeded, but the local source row was missing.",
+      );
+    }
 
-  await db
-    .update(schema.contentDatabaseSourceFields)
-    .set({
-      freshness: "fresh",
-      lastSyncedAt: args.now,
-      updatedAt: args.now,
-    })
-    .where(eq(schema.contentDatabaseSourceFields.sourceId, args.source.id));
-  await db
-    .update(schema.contentDatabaseSources)
-    .set({
-      syncState: "idle",
-      freshness: "fresh",
-      lastRefreshedAt: args.now,
-      lastSourceUpdatedAt: patch.lastSourceUpdatedAt,
-      lastError: null,
-      updatedAt: args.now,
-    })
-    .where(eq(schema.contentDatabaseSources.id, args.source.id));
+    await tx
+      .update(schema.contentDatabaseSourceFields)
+      .set({
+        freshness: "fresh",
+        lastSyncedAt: args.now,
+        updatedAt: args.now,
+      })
+      .where(eq(schema.contentDatabaseSourceFields.sourceId, args.source.id));
+    await tx
+      .update(schema.contentDatabaseSources)
+      .set({
+        syncState: "idle",
+        freshness: "fresh",
+        lastRefreshedAt: args.now,
+        lastSourceUpdatedAt: patch.lastSourceUpdatedAt,
+        lastError: null,
+        updatedAt: args.now,
+      })
+      .where(eq(schema.contentDatabaseSources.id, args.source.id));
+  });
 }
 
 export function realExecutionDeps(

package/corpus/templates/content/actions/materialize-builder-required-fields.ts

@@ -19,6 +19,7 @@ import {
 } from "../shared/properties.js";
 import { chunks } from "./_batch-utils.js";
 import { readBuilderCmsContentEntries } from "./_builder-cms-read-client.js";
+import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
   builderReferenceIdSourceValueKey,
   resolveDatabaseForSourceMutation,
@@ -352,6 +353,12 @@ export default defineAction({
         .select()
         .from(schema.contentDatabaseSourceRows)
         .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
+      await lockDatabaseMemberships(
+        tx,
+        currentSourceRows
+          .map((row) => row.databaseItemId)
+          .filter((itemId) => itemId.length > 0),
+      );
       const [maxPosition] = await tx
         .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
         .from(schema.documentPropertyDefinitions)

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

@@ -0,0 +1,183 @@
+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 { getDb, schema } from "../server/db/index.js";
+import { assertNotWorkspaceCatalogDocuments } from "./_content-space-catalog-guards.js";
+import { lockDatabaseMemberships } from "./_database-membership-lock.js";
+import {
+  databaseRowBatchSchema,
+  renumberDatabaseRows,
+  resolveDatabaseRowsForBatch,
+} from "./_database-row-batch.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+import {
+  databaseItemsPositionScope,
+  withPositionLock,
+} from "./_position-utils.js";
+
+export default defineAction({
+  description:
+    "Remove one or more page memberships from a content database in one atomic batch without deleting the pages. Use this once for two or more selected or named rows instead of looping page operations.",
+  schema: databaseRowBatchSchema,
+  run: async (args) => {
+    const db = getDb();
+    const { database, rows } = await resolveDatabaseRowsForBatch(args, {
+      includeTrashed: true,
+    });
+
+    if (database.systemRole === "favorites") {
+      await assertAccess("document", database.documentId, "editor");
+      const removedItemIds = rows.map((row) => row.item.id);
+      const removedDocumentIds = rows.map((row) => row.document.id);
+      const now = new Date().toISOString();
+      await withPositionLock(databaseItemsPositionScope(database.id), () =>
+        db.transaction(async (tx) => {
+          if (removedItemIds.length > 0) {
+            await tx
+              .delete(schema.contentDatabaseItems)
+              .where(inArray(schema.contentDatabaseItems.id, removedItemIds));
+          }
+          await renumberDatabaseRows(
+            tx as unknown as ReturnType<typeof getDb>,
+            database,
+            now,
+          );
+        }),
+      );
+      await writeAppState("refresh-signal", { ts: Date.now() });
+      return {
+        ...(await getContentDatabaseResponse(database.id, {
+          limit: 100,
+          offset: 0,
+        })),
+        removedItemIds,
+        removedDocumentIds,
+        removedCount: removedItemIds.length,
+      };
+    }
+
+    await assertAccess("document", database.documentId, "admin");
+    for (const row of rows) {
+      await assertAccess("document", row.document.id, "viewer");
+    }
+
+    const removedItemIds = rows.map((row) => row.item.id);
+    const removedDocumentIds = rows.map((row) => row.document.id);
+    await assertNotWorkspaceCatalogDocuments(
+      db,
+      removedDocumentIds,
+      "removed from a database",
+    );
+    if (database.systemRole) {
+      throw new Error(
+        "System database memberships cannot be removed from this surface.",
+      );
+    }
+
+    const now = new Date().toISOString();
+
+    await withPositionLock(databaseItemsPositionScope(database.id), () =>
+      db.transaction(async (tx) => {
+        if (removedItemIds.length > 0) {
+          await lockDatabaseMemberships(tx, removedItemIds);
+          const [sourceRow, hydrationRow] = await Promise.all([
+            tx
+              .select({ id: schema.contentDatabaseSourceRows.id })
+              .from(schema.contentDatabaseSourceRows)
+              .where(
+                inArray(
+                  schema.contentDatabaseSourceRows.databaseItemId,
+                  removedItemIds,
+                ),
+              )
+              .limit(1),
+            tx
+              .select({ id: schema.contentDatabaseBodyHydrationQueue.id })
+              .from(schema.contentDatabaseBodyHydrationQueue)
+              .where(
+                inArray(
+                  schema.contentDatabaseBodyHydrationQueue.databaseItemId,
+                  removedItemIds,
+                ),
+              )
+              .limit(1),
+          ]);
+          if (sourceRow.length > 0 || hydrationRow.length > 0) {
+            throw new Error(
+              "Source-backed rows cannot be removed from this database.",
+            );
+          }
+        }
+        const propertyIds = (
+          await tx
+            .select({ id: schema.documentPropertyDefinitions.id })
+            .from(schema.documentPropertyDefinitions)
+            .where(
+              eq(schema.documentPropertyDefinitions.databaseId, database.id),
+            )
+        ).map((property) => property.id);
+        if (removedDocumentIds.length > 0 && propertyIds.length > 0) {
+          await tx
+            .delete(schema.documentPropertyValues)
+            .where(
+              and(
+                inArray(
+                  schema.documentPropertyValues.documentId,
+                  removedDocumentIds,
+                ),
+                inArray(schema.documentPropertyValues.propertyId, propertyIds),
+              ),
+            );
+          await tx
+            .delete(schema.documentBlockFieldContents)
+            .where(
+              and(
+                inArray(
+                  schema.documentBlockFieldContents.documentId,
+                  removedDocumentIds,
+                ),
+                inArray(
+                  schema.documentBlockFieldContents.propertyId,
+                  propertyIds,
+                ),
+              ),
+            );
+        }
+        if (removedItemIds.length > 0) {
+          await tx
+            .delete(schema.contentDatabaseItems)
+            .where(inArray(schema.contentDatabaseItems.id, removedItemIds));
+        }
+        await renumberDatabaseRows(
+          tx as unknown as ReturnType<typeof getDb>,
+          database,
+          now,
+        );
+
+        if (removedItemIds.length > 0) {
+          const remaining = await tx
+            .select({ id: schema.contentDatabaseItems.id })
+            .from(schema.contentDatabaseItems)
+            .where(inArray(schema.contentDatabaseItems.id, removedItemIds));
+          if (remaining.length > 0) {
+            throw new Error("Database memberships were not fully removed.");
+          }
+        }
+      }),
+    );
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id, {
+        limit: 100,
+        offset: 0,
+      })),
+      removedItemIds,
+      removedDocumentIds,
+      removedCount: removedItemIds.length,
+    };
+  },
+});