@agent-native/core 0.137.7 → 0.138.0

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

@@ -8,35 +8,52 @@ import type {
   ContentDatabaseResponse,
   DisconnectContentDatabaseSourceRequest,
 } from "../shared/api.js";
+import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import {
   getExistingSource,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 
-async function deleteSourceRecords(sourceId: string) {
+async function deleteSourceRecords(databaseId: string, sourceId: string) {
   const db = getDb();
-  await db
-    .delete(schema.contentDatabaseBodyHydrationQueue)
-    .where(eq(schema.contentDatabaseBodyHydrationQueue.sourceId, sourceId));
-  await db
-    .delete(schema.contentDatabaseSourceExecutions)
-    .where(eq(schema.contentDatabaseSourceExecutions.sourceId, sourceId));
-  await db
-    .delete(schema.contentDatabaseSourceChangeReviews)
-    .where(eq(schema.contentDatabaseSourceChangeReviews.sourceId, sourceId));
-  await db
-    .delete(schema.contentDatabaseSourceChangeSets)
-    .where(eq(schema.contentDatabaseSourceChangeSets.sourceId, sourceId));
-  await db
-    .delete(schema.contentDatabaseSourceRows)
-    .where(eq(schema.contentDatabaseSourceRows.sourceId, sourceId));
-  await db
-    .delete(schema.contentDatabaseSourceFields)
-    .where(eq(schema.contentDatabaseSourceFields.sourceId, sourceId));
-  await db
-    .delete(schema.contentDatabaseSources)
-    .where(eq(schema.contentDatabaseSources.id, sourceId));
+  await db.transaction(async (tx) => {
+    await lockContentDatabaseMutation(
+      tx as unknown as ReturnType<typeof getDb>,
+      databaseId,
+    );
+    const [source] = await tx
+      .select({ id: schema.contentDatabaseSources.id })
+      .from(schema.contentDatabaseSources)
+      .where(
+        and(
+          eq(schema.contentDatabaseSources.id, sourceId),
+          eq(schema.contentDatabaseSources.databaseId, databaseId),
+        ),
+      );
+    if (!source) return;
+    await tx
+      .delete(schema.contentDatabaseBodyHydrationQueue)
+      .where(eq(schema.contentDatabaseBodyHydrationQueue.sourceId, sourceId));
+    await tx
+      .delete(schema.contentDatabaseSourceExecutions)
+      .where(eq(schema.contentDatabaseSourceExecutions.sourceId, sourceId));
+    await tx
+      .delete(schema.contentDatabaseSourceChangeReviews)
+      .where(eq(schema.contentDatabaseSourceChangeReviews.sourceId, sourceId));
+    await tx
+      .delete(schema.contentDatabaseSourceChangeSets)
+      .where(eq(schema.contentDatabaseSourceChangeSets.sourceId, sourceId));
+    await tx
+      .delete(schema.contentDatabaseSourceRows)
+      .where(eq(schema.contentDatabaseSourceRows.sourceId, sourceId));
+    await tx
+      .delete(schema.contentDatabaseSourceFields)
+      .where(eq(schema.contentDatabaseSourceFields.sourceId, sourceId));
+    await tx
+      .delete(schema.contentDatabaseSources)
+      .where(eq(schema.contentDatabaseSources.id, sourceId));
+  });
 }
 
 export default defineAction({
@@ -70,13 +87,13 @@ export default defineAction({
             eq(schema.contentDatabaseSources.databaseId, database.id),
           ),
         );
-      if (target) await deleteSourceRecords(target.id);
+      if (target) await deleteSourceRecords(database.id, target.id);
       return getContentDatabaseResponse(database.id, { limit: 100, offset: 0 });
     }
 
     const source = await getExistingSource(database.id);
     if (source) {
-      await deleteSourceRecords(source.id);
+      await deleteSourceRecords(database.id, source.id);
     }
 
     return getContentDatabaseResponse(database.id, { limit: 100, offset: 0 });

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

@@ -6,6 +6,10 @@ import { and, eq, gte, isNull, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  lockContentDatabaseMutation,
+  touchContentDatabase,
+} from "./_content-database-mutation-lock.js";
 import { ensureDocumentFilesMembership } from "./_content-files.js";
 import { assertNotWorkspaceCatalogDocuments } from "./_content-space-catalog-guards.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
@@ -69,15 +73,6 @@ export default defineAction({
     const now = new Date().toISOString();
     const nextDocumentId = nanoid();
     const nextItemId = nanoid();
-    const nextTitle =
-      title?.trim() || `Copy of ${row.document.title.trim() || "Untitled"}`;
-    const nextPosition = row.item.position + 1;
-
-    const values = await db
-      .select()
-      .from(schema.documentPropertyValues)
-      .where(eq(schema.documentPropertyValues.documentId, row.document.id));
-
     const inheritedShares = await db
       .select({
         principalType: schema.documentShares.principalType,
@@ -88,18 +83,52 @@ 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}` })
+      await lockContentDatabaseMutation(
+        tx as unknown as ReturnType<typeof getDb>,
+        row.database.id,
+      );
+      await touchContentDatabase(
+        tx as unknown as ReturnType<typeof getDb>,
+        row.database.id,
+        now,
+      );
+      const [lockedRow] = await tx
+        .select({
+          item: schema.contentDatabaseItems,
+          document: schema.documents,
+        })
+        .from(schema.contentDatabaseItems)
+        .innerJoin(
+          schema.documents,
+          eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+        )
         .where(
           and(
-            eq(schema.contentDatabases.id, row.database.id),
-            eq(schema.contentDatabases.ownerEmail, row.database.ownerEmail),
-            isNull(schema.contentDatabases.deletedAt),
+            eq(schema.contentDatabaseItems.id, row.item.id),
+            eq(schema.contentDatabaseItems.databaseId, row.database.id),
+            eq(schema.contentDatabaseItems.documentId, row.document.id),
+            isNull(schema.documents.trashedAt),
           ),
-        )
-        .returning({ id: schema.contentDatabases.id });
-      if (!lockedDatabase) throw new Error("Database is no longer active.");
+        );
+      if (!lockedRow) {
+        throw new Error("Database row changed while duplication was waiting.");
+      }
+      if (lockedRow.document.spaceId !== row.database.spaceId) {
+        throw new Error(
+          "Cannot duplicate a database row across Content spaces.",
+        );
+      }
+
+      const nextTitle =
+        title?.trim() ||
+        `Copy of ${lockedRow.document.title.trim() || "Untitled"}`;
+      const nextPosition = lockedRow.item.position + 1;
+      const values = await tx
+        .select()
+        .from(schema.documentPropertyValues)
+        .where(
+          eq(schema.documentPropertyValues.documentId, lockedRow.document.id),
+        );
       const [claimedSource] = await tx
         .select({ id: schema.contentDatabaseItemKeyClaims.id })
         .from(schema.contentDatabaseItemKeyClaims)
@@ -123,7 +152,10 @@ export default defineAction({
         })
         .where(
           and(
-            eq(schema.contentDatabaseItems.databaseId, row.item.databaseId),
+            eq(
+              schema.contentDatabaseItems.databaseId,
+              lockedRow.item.databaseId,
+            ),
             gte(schema.contentDatabaseItems.position, nextPosition),
           ),
         );
@@ -136,7 +168,7 @@ export default defineAction({
         })
         .where(
           and(
-            eq(schema.documents.ownerEmail, row.document.ownerEmail),
+            eq(schema.documents.ownerEmail, lockedRow.document.ownerEmail),
             eq(schema.documents.parentId, row.database.documentId),
             gte(schema.documents.position, nextPosition),
           ),
@@ -145,25 +177,25 @@ export default defineAction({
       await tx.insert(schema.documents).values({
         id: nextDocumentId,
         spaceId: row.database.spaceId,
-        ownerEmail: row.document.ownerEmail,
-        orgId: row.document.orgId,
+        ownerEmail: lockedRow.document.ownerEmail,
+        orgId: lockedRow.document.orgId,
         parentId: row.database.documentId,
         title: nextTitle,
-        content: row.document.content,
-        icon: row.document.icon,
+        content: lockedRow.document.content,
+        icon: lockedRow.document.icon,
         position: nextPosition,
         isFavorite: 0,
-        hideFromSearch: row.document.hideFromSearch,
-        visibility: row.document.visibility,
+        hideFromSearch: lockedRow.document.hideFromSearch,
+        visibility: lockedRow.document.visibility,
         createdAt: now,
         updatedAt: now,
       });
 
       await tx.insert(schema.contentDatabaseItems).values({
         id: nextItemId,
-        ownerEmail: row.item.ownerEmail,
-        orgId: row.item.orgId,
-        databaseId: row.item.databaseId,
+        ownerEmail: lockedRow.item.ownerEmail,
+        orgId: lockedRow.item.orgId,
+        databaseId: lockedRow.item.databaseId,
         documentId: nextDocumentId,
         position: nextPosition,
         createdAt: now,
@@ -178,7 +210,7 @@ export default defineAction({
             principalType: share.principalType,
             principalId: share.principalId,
             role: share.role,
-            createdBy: getRequestUserEmail() ?? row.document.ownerEmail,
+            createdBy: getRequestUserEmail() ?? lockedRow.document.ownerEmail,
             createdAt: now,
           })),
         );
@@ -188,7 +220,7 @@ export default defineAction({
         await tx.insert(schema.documentPropertyValues).values(
           values.map((value) => ({
             id: nanoid(),
-            ownerEmail: row.document.ownerEmail,
+            ownerEmail: lockedRow.document.ownerEmail,
             documentId: nextDocumentId,
             propertyId: value.propertyId,
             valueJson: value.valueJson,

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

@@ -2,9 +2,13 @@ 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, isNull, sql } from "drizzle-orm";
+import { and, asc, eq, gte, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  lockContentDatabaseMutation,
+  touchContentDatabase,
+} from "./_content-database-mutation-lock.js";
 import { ensureDocumentsFilesMembership } from "./_content-files.js";
 import { assertNotWorkspaceCatalogDocuments } from "./_content-space-catalog-guards.js";
 import {
@@ -41,32 +45,8 @@ export default defineAction({
     );
     const sourceItemIds = rows.map((row) => row.item.id);
     const now = new Date().toISOString();
-    const insertionPosition =
-      Math.max(...rows.map((row) => row.item.position)) + 1;
     const currentUserEmail = getRequestUserEmail() ?? database.ownerEmail;
 
-    const values =
-      sourceDocumentIds.length > 0
-        ? await db
-            .select()
-            .from(schema.documentPropertyValues)
-            .where(
-              inArray(
-                schema.documentPropertyValues.documentId,
-                sourceDocumentIds,
-              ),
-            )
-        : [];
-    const valuesByDocumentId = new Map<
-      string,
-      Array<typeof schema.documentPropertyValues.$inferSelect>
-    >();
-    for (const value of values) {
-      const list = valuesByDocumentId.get(value.documentId) ?? [];
-      list.push(value);
-      valuesByDocumentId.set(value.documentId, list);
-    }
-
     const inheritedShares = await db
       .select({
         principalType: schema.documentShares.principalType,
@@ -76,28 +56,63 @@ export default defineAction({
       .from(schema.documentShares)
       .where(eq(schema.documentShares.resourceId, database.documentId));
 
-    const duplicates = rows.map((row, index) => ({
+    const duplicates = rows.map((row) => ({
       sourceItemId: row.item.id,
       sourceDocumentId: row.document.id,
       duplicatedItemId: nanoid(),
       duplicatedDocumentId: nanoid(),
-      position: insertionPosition + index,
-      row,
     }));
 
     await db.transaction(async (tx) => {
-      const [lockedDatabase] = await tx
-        .update(schema.contentDatabases)
-        .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+      await lockContentDatabaseMutation(
+        tx as unknown as ReturnType<typeof getDb>,
+        database.id,
+      );
+      await touchContentDatabase(
+        tx as unknown as ReturnType<typeof getDb>,
+        database.id,
+        now,
+      );
+      const lockedRows = await tx
+        .select({
+          item: schema.contentDatabaseItems,
+          document: schema.documents,
+        })
+        .from(schema.contentDatabaseItems)
+        .innerJoin(
+          schema.documents,
+          eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+        )
         .where(
           and(
-            eq(schema.contentDatabases.id, database.id),
-            eq(schema.contentDatabases.ownerEmail, database.ownerEmail),
-            isNull(schema.contentDatabases.deletedAt),
+            eq(schema.contentDatabaseItems.databaseId, database.id),
+            inArray(schema.contentDatabaseItems.id, sourceItemIds),
+            isNull(schema.documents.trashedAt),
           ),
         )
-        .returning({ id: schema.contentDatabases.id });
-      if (!lockedDatabase) throw new Error("Database is no longer active.");
+        .orderBy(asc(schema.contentDatabaseItems.position));
+      const lockedRowsByItemId = new Map(
+        lockedRows.map((lockedRow) => [lockedRow.item.id, lockedRow]),
+      );
+      if (
+        lockedRows.length !== rows.length ||
+        rows.some(
+          (row) =>
+            lockedRowsByItemId.get(row.item.id)?.document.id !==
+            row.document.id,
+        )
+      ) {
+        throw new Error("Database rows changed while duplication was waiting.");
+      }
+      if (
+        lockedRows.some(
+          (lockedRow) => lockedRow.document.spaceId !== database.spaceId,
+        )
+      ) {
+        throw new Error(
+          "Cannot duplicate database rows across Content spaces.",
+        );
+      }
       const [claimedSource] = await tx
         .select({ id: schema.contentDatabaseItemKeyClaims.id })
         .from(schema.contentDatabaseItemKeyClaims)
@@ -116,10 +131,38 @@ export default defineAction({
           "Rows with active stable-key claims cannot be duplicated.",
         );
       }
+      const insertionPosition =
+        Math.max(...lockedRows.map((lockedRow) => lockedRow.item.position)) + 1;
+      const lockedDuplicates = duplicates.map((duplicate, index) => ({
+        ...duplicate,
+        position: insertionPosition + index,
+        row: lockedRowsByItemId.get(duplicate.sourceItemId)!,
+      }));
+      const values =
+        sourceDocumentIds.length > 0
+          ? await tx
+              .select()
+              .from(schema.documentPropertyValues)
+              .where(
+                inArray(
+                  schema.documentPropertyValues.documentId,
+                  sourceDocumentIds,
+                ),
+              )
+          : [];
+      const valuesByDocumentId = new Map<
+        string,
+        Array<typeof schema.documentPropertyValues.$inferSelect>
+      >();
+      for (const value of values) {
+        const list = valuesByDocumentId.get(value.documentId) ?? [];
+        list.push(value);
+        valuesByDocumentId.set(value.documentId, list);
+      }
       await tx
         .update(schema.contentDatabaseItems)
         .set({
-          position: sql`${schema.contentDatabaseItems.position} + ${duplicates.length}`,
+          position: sql`${schema.contentDatabaseItems.position} + ${lockedDuplicates.length}`,
           updatedAt: now,
         })
         .where(
@@ -132,7 +175,7 @@ export default defineAction({
       await tx
         .update(schema.documents)
         .set({
-          position: sql`${schema.documents.position} + ${duplicates.length}`,
+          position: sql`${schema.documents.position} + ${lockedDuplicates.length}`,
           updatedAt: now,
         })
         .where(
@@ -144,7 +187,7 @@ export default defineAction({
         );
 
       await tx.insert(schema.documents).values(
-        duplicates.map((duplicate) => ({
+        lockedDuplicates.map((duplicate) => ({
           id: duplicate.duplicatedDocumentId,
           spaceId: database.spaceId,
           ownerEmail: duplicate.row.document.ownerEmail,
@@ -163,7 +206,7 @@ export default defineAction({
       );
 
       await tx.insert(schema.contentDatabaseItems).values(
-        duplicates.map((duplicate) => ({
+        lockedDuplicates.map((duplicate) => ({
           id: duplicate.duplicatedItemId,
           ownerEmail: duplicate.row.item.ownerEmail,
           orgId: duplicate.row.item.orgId,
@@ -175,7 +218,7 @@ export default defineAction({
         })),
       );
 
-      const duplicatedValues = duplicates.flatMap((duplicate) =>
+      const duplicatedValues = lockedDuplicates.flatMap((duplicate) =>
         (valuesByDocumentId.get(duplicate.sourceDocumentId) ?? []).map(
           (value) => ({
             id: nanoid(),
@@ -194,7 +237,7 @@ export default defineAction({
 
       if (inheritedShares.length > 0) {
         await tx.insert(schema.documentShares).values(
-          duplicates.flatMap((duplicate) =>
+          lockedDuplicates.flatMap((duplicate) =>
             inheritedShares.map((share) => ({
               id: nanoid(),
               resourceId: duplicate.duplicatedDocumentId,
@@ -209,7 +252,7 @@ export default defineAction({
       }
       await ensureDocumentsFilesMembership(
         tx,
-        duplicates.map((duplicate) => duplicate.duplicatedDocumentId),
+        lockedDuplicates.map((duplicate) => duplicate.duplicatedDocumentId),
         now,
       );
     });

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

@@ -10,6 +10,7 @@ import {
   serializePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
   propertyDefinitionsPositionScope,
@@ -65,19 +66,14 @@ export default defineAction({
 
     const now = new Date().toISOString();
     const newPropertyId = nanoid();
-    const isBlocks = isBlocksPropertyType(
-      definition.type as DocumentPropertyType,
-    );
-    // A duplicated Blocks field is a brand-new, independent, EMPTY field — never
-    // primary (only one field backs the body) and with no copied content.
-    const optionsJson = isBlocks
-      ? serializePropertyOptions({ blocks: { primary: false } })
-      : definition.optionsJson;
-
     await withPositionLock(
       propertyDefinitionsPositionScope(database.id),
       async () => {
         await db.transaction(async (tx) => {
+          await lockContentDatabaseMutation(
+            tx as unknown as ReturnType<typeof getDb>,
+            database.id,
+          );
           const memberships = await tx
             .select({ id: schema.contentDatabaseItems.id })
             .from(schema.contentDatabaseItems)
@@ -86,6 +82,33 @@ export default defineAction({
             tx,
             memberships.map((membership) => membership.id),
           );
+          const [lockedDefinition] = await tx
+            .select()
+            .from(schema.documentPropertyDefinitions)
+            .where(
+              and(
+                eq(schema.documentPropertyDefinitions.id, propertyId),
+                eq(
+                  schema.documentPropertyDefinitions.ownerEmail,
+                  document.ownerEmail,
+                ),
+                eq(schema.documentPropertyDefinitions.databaseId, database.id),
+              ),
+            );
+          if (!lockedDefinition) {
+            throw new Error(`Property "${propertyId}" not found`);
+          }
+          if (lockedDefinition.systemRole) {
+            throw new Error("System properties cannot be duplicated.");
+          }
+          const isBlocks = isBlocksPropertyType(
+            lockedDefinition.type as DocumentPropertyType,
+          );
+          // A duplicated Blocks field is a brand-new, independent, EMPTY field — never
+          // primary (only one field backs the body) and with no copied content.
+          const optionsJson = isBlocks
+            ? serializePropertyOptions({ blocks: { primary: false } })
+            : lockedDefinition.optionsJson;
 
           const [maxPos] = await tx
             .select({
@@ -104,12 +127,12 @@ export default defineAction({
 
           await tx.insert(schema.documentPropertyDefinitions).values({
             id: newPropertyId,
-            ownerEmail: definition.ownerEmail,
-            orgId: definition.orgId,
+            ownerEmail: lockedDefinition.ownerEmail,
+            orgId: lockedDefinition.orgId,
             databaseId: database.id,
-            name: `${definition.name} copy`,
-            type: definition.type,
-            visibility: definition.visibility,
+            name: `${lockedDefinition.name} copy`,
+            type: lockedDefinition.type,
+            visibility: lockedDefinition.visibility,
             optionsJson,
             position: (maxPos?.max ?? -1) + 1,
             createdAt: now,