@agent-native/core 0.137.8 → 0.138.0

package/corpus/templates/content/actions/_database-source-utils.ts

@@ -86,6 +86,7 @@ import {
   type ExistingBuilderSourceRowIdentity,
 } from "./_builder-cms-source-adapter.js";
 import { mergeBuilderCmsWriteSettingsIntoJson } from "./_builder-cms-write-settings.js";
+import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import { ensureDocumentsFilesMembership } from "./_content-files.js";
 import {
   organizationContentSpaceId,
@@ -7018,26 +7019,42 @@ export async function replaceSourceMetadata(args: {
       })
       .where(eq(schema.contentDatabaseSources.id, args.source.id));
   } else {
-    await db.insert(schema.contentDatabaseSources).values({
-      id: sourceId,
-      ownerEmail: args.database.ownerEmail,
-      orgId: args.database.orgId,
-      databaseId: args.database.id,
-      sourceType: args.sourceType,
-      sourceName: args.sourceName,
-      sourceTable: args.sourceTable,
-      syncState: "linked",
-      freshness: "fresh",
-      capabilitiesJson: sourceCapabilitiesForType(args.sourceType),
-      metadataJson: serializeSourceMetadataRecord({
+    await db.transaction(async (tx) => {
+      await lockContentDatabaseMutation(
+        tx as unknown as ReturnType<typeof getDb>,
+        args.database.id,
+      );
+      const [existing] = await tx
+        .select({ id: schema.contentDatabaseSources.id })
+        .from(schema.contentDatabaseSources)
+        .where(eq(schema.contentDatabaseSources.databaseId, args.database.id))
+        .limit(1);
+      if (existing) {
+        throw new Error(
+          "Database source state changed before attachment completed.",
+        );
+      }
+      await tx.insert(schema.contentDatabaseSources).values({
+        id: sourceId,
+        ownerEmail: args.database.ownerEmail,
+        orgId: args.database.orgId,
+        databaseId: args.database.id,
         sourceType: args.sourceType,
+        sourceName: args.sourceName,
         sourceTable: args.sourceTable,
-      }),
-      lastRefreshedAt: args.now,
-      lastSourceUpdatedAt: args.now,
-      lastError: null,
-      createdAt: args.now,
-      updatedAt: args.now,
+        syncState: "linked",
+        freshness: "fresh",
+        capabilitiesJson: sourceCapabilitiesForType(args.sourceType),
+        metadataJson: serializeSourceMetadataRecord({
+          sourceType: args.sourceType,
+          sourceTable: args.sourceTable,
+        }),
+        lastRefreshedAt: args.now,
+        lastSourceUpdatedAt: args.now,
+        lastError: null,
+        createdAt: args.now,
+        updatedAt: args.now,
+      });
     });
   }
 
@@ -7050,6 +7067,7 @@ export async function replaceSourceMetadata(args: {
  */
 export async function insertSecondarySource(args: {
   database: ContentDatabaseRow;
+  expectedPrimarySourceId: string;
   sourceType: ContentDatabaseSourceType;
   sourceName: string;
   sourceTable: string;
@@ -7057,26 +7075,54 @@ export async function insertSecondarySource(args: {
 }): Promise<string> {
   const db = getDb();
   const sourceId = crypto.randomUUID();
-  await db.insert(schema.contentDatabaseSources).values({
-    id: sourceId,
-    ownerEmail: args.database.ownerEmail,
-    orgId: args.database.orgId,
-    databaseId: args.database.id,
-    sourceType: args.sourceType,
-    sourceName: args.sourceName,
-    sourceTable: args.sourceTable,
-    syncState: "linked",
-    freshness: "fresh",
-    capabilitiesJson: sourceCapabilitiesForType(args.sourceType),
-    metadataJson: serializeSourceMetadataRecord({
+  await db.transaction(async (tx) => {
+    await lockContentDatabaseMutation(
+      tx as unknown as ReturnType<typeof getDb>,
+      args.database.id,
+    );
+    const sources = await tx
+      .select({
+        id: schema.contentDatabaseSources.id,
+        sourceType: schema.contentDatabaseSources.sourceType,
+        sourceTable: schema.contentDatabaseSources.sourceTable,
+      })
+      .from(schema.contentDatabaseSources)
+      .where(eq(schema.contentDatabaseSources.databaseId, args.database.id));
+    if (!sources.some((source) => source.id === args.expectedPrimarySourceId)) {
+      throw new Error(
+        "Database source state changed before attachment completed.",
+      );
+    }
+    if (
+      sources.some(
+        (source) =>
+          source.sourceType === args.sourceType &&
+          source.sourceTable === args.sourceTable,
+      )
+    ) {
+      throw new Error(`"${args.sourceTable}" is already attached as a source.`);
+    }
+    await tx.insert(schema.contentDatabaseSources).values({
+      id: sourceId,
+      ownerEmail: args.database.ownerEmail,
+      orgId: args.database.orgId,
+      databaseId: args.database.id,
       sourceType: args.sourceType,
+      sourceName: args.sourceName,
       sourceTable: args.sourceTable,
-    }),
-    lastRefreshedAt: args.now,
-    lastSourceUpdatedAt: args.now,
-    lastError: null,
-    createdAt: args.now,
-    updatedAt: args.now,
+      syncState: "linked",
+      freshness: "fresh",
+      capabilitiesJson: sourceCapabilitiesForType(args.sourceType),
+      metadataJson: serializeSourceMetadataRecord({
+        sourceType: args.sourceType,
+        sourceTable: args.sourceTable,
+      }),
+      lastRefreshedAt: args.now,
+      lastSourceUpdatedAt: args.now,
+      lastError: null,
+      createdAt: args.now,
+      updatedAt: args.now,
+    });
   });
   return sourceId;
 }

package/corpus/templates/content/actions/_database-utils.ts

@@ -1448,6 +1448,11 @@ export async function deleteDatabaseDataForDocument(
     await db
       .delete(schema.contentDatabaseSources)
       .where(eq(schema.contentDatabaseSources.databaseId, database.id));
+    await db
+      .delete(schema.contentDatabaseMigrationReceipts)
+      .where(
+        eq(schema.contentDatabaseMigrationReceipts.databaseId, database.id),
+      );
     await db
       .delete(schema.documentPropertyDefinitions)
       .where(eq(schema.documentPropertyDefinitions.databaseId, database.id));

package/corpus/templates/content/actions/_delete-content-space.ts

@@ -2,11 +2,15 @@ import { and, eq } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
 import { resolveContentSpaceAccess } from "./_content-space-access.js";
-import { deleteDocumentRecursive } from "./delete-document.js";
+import {
+  deleteDocumentRootsRecursive,
+  PermanentDeleteScopeChangedError,
+} from "./delete-document.js";
 
 type Db = ReturnType<typeof getDb>;
+const MAX_DELETE_SCOPE_ATTEMPTS = 3;
 
-export async function deleteUserContentSpace(db: Db, spaceId: string) {
+async function deleteUserContentSpaceOnce(db: Db, spaceId: string) {
   return db.transaction(async (tx) => {
     const scopedDb = tx as unknown as Db;
     const access = await resolveContentSpaceAccess(spaceId, "editor", {
@@ -45,14 +49,9 @@ export async function deleteUserContentSpace(db: Db, spaceId: string) {
     await scopedDb
       .delete(schema.contentSpaceCatalogItems)
       .where(eq(schema.contentSpaceCatalogItems.id, mapping.id));
-    const deletedCatalogDocuments = await deleteDocumentRecursive(
-      scopedDb,
-      mapping.documentId,
-      access.space.ownerEmail,
-    );
-    const deletedWorkspaceDocuments = await deleteDocumentRecursive(
+    const deletedDocuments = await deleteDocumentRootsRecursive(
       scopedDb,
-      filesDatabase.documentId,
+      [mapping.documentId, filesDatabase.documentId],
       access.space.ownerEmail,
     );
 
@@ -77,8 +76,23 @@ export async function deleteUserContentSpace(db: Db, spaceId: string) {
 
     return {
       spaceId,
-      deletedDocuments:
-        deletedCatalogDocuments.length + deletedWorkspaceDocuments.length,
+      deletedDocuments: deletedDocuments.length,
     };
   });
 }
+
+export async function deleteUserContentSpace(db: Db, spaceId: string) {
+  for (let attempt = 1; attempt <= MAX_DELETE_SCOPE_ATTEMPTS; attempt += 1) {
+    try {
+      return await deleteUserContentSpaceOnce(db, spaceId);
+    } catch (error) {
+      if (
+        !(error instanceof PermanentDeleteScopeChangedError) ||
+        attempt === MAX_DELETE_SCOPE_ATTEMPTS
+      ) {
+        throw error;
+      }
+    }
+  }
+  throw new Error("Workspace deletion did not complete.");
+}

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

@@ -10,6 +10,10 @@ import {
   isComputedPropertyType,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import {
+  lockContentDatabaseMutation,
+  touchContentDatabase,
+} from "./_content-database-mutation-lock.js";
 import { ensureDocumentFilesMembership } from "./_content-files.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import {
@@ -97,54 +101,68 @@ export default defineAction({
       .where(eq(schema.documentShares.resourceId, database.documentId));
 
     const initialValues = Object.entries(propertyValues ?? {});
-    const propertyValueRows: Array<
-      typeof schema.documentPropertyValues.$inferInsert
-    > = [];
-    if (initialValues.length > 0) {
-      const requestedPropertyIds = initialValues.map(
-        ([propertyId]) => propertyId,
-      );
-      const definitions = await db
-        .select()
-        .from(schema.documentPropertyDefinitions)
-        .where(
-          and(
-            eq(
-              schema.documentPropertyDefinitions.ownerEmail,
-              database.ownerEmail,
-            ),
-            eq(schema.documentPropertyDefinitions.databaseId, databaseId),
-            inArray(
-              schema.documentPropertyDefinitions.id,
-              requestedPropertyIds,
-            ),
-          ),
-        );
-      const definitionById = new Map(
-        definitions.map((definition) => [definition.id, definition]),
-      );
-
-      for (const [propertyId, value] of initialValues) {
-        const definition = definitionById.get(propertyId);
-        const type = definition?.type as DocumentPropertyType | undefined;
-        if (!definition || !type || isComputedPropertyType(type)) continue;
-        propertyValueRows.push({
-          id: nanoid(),
-          ownerEmail: database.ownerEmail,
-          documentId,
-          propertyId,
-          valueJson: normalizedValueJson(type, value),
-          createdAt: now,
-          updatedAt: now,
-        });
-      }
-    }
 
     await withPositionLock(
       documentsPositionScope(database.ownerEmail, database.documentId),
       () =>
         withPositionLock(databaseItemsPositionScope(databaseId), async () => {
           await db.transaction(async (tx) => {
+            await lockContentDatabaseMutation(
+              tx as unknown as ReturnType<typeof getDb>,
+              databaseId,
+            );
+            await touchContentDatabase(
+              tx as unknown as ReturnType<typeof getDb>,
+              databaseId,
+              now,
+            );
+            const propertyValueRows: Array<
+              typeof schema.documentPropertyValues.$inferInsert
+            > = [];
+            if (initialValues.length > 0) {
+              const requestedPropertyIds = initialValues.map(
+                ([propertyId]) => propertyId,
+              );
+              const definitions = await tx
+                .select()
+                .from(schema.documentPropertyDefinitions)
+                .where(
+                  and(
+                    eq(
+                      schema.documentPropertyDefinitions.ownerEmail,
+                      database.ownerEmail,
+                    ),
+                    eq(
+                      schema.documentPropertyDefinitions.databaseId,
+                      databaseId,
+                    ),
+                    inArray(
+                      schema.documentPropertyDefinitions.id,
+                      requestedPropertyIds,
+                    ),
+                  ),
+                );
+              const definitionById = new Map(
+                definitions.map((definition) => [definition.id, definition]),
+              );
+              for (const [propertyId, value] of initialValues) {
+                const definition = definitionById.get(propertyId);
+                const type = definition?.type as
+                  | DocumentPropertyType
+                  | undefined;
+                if (!definition || !type || isComputedPropertyType(type))
+                  continue;
+                propertyValueRows.push({
+                  id: nanoid(),
+                  ownerEmail: database.ownerEmail,
+                  documentId,
+                  propertyId,
+                  valueJson: normalizedValueJson(type, value),
+                  createdAt: now,
+                  updatedAt: now,
+                });
+              }
+            }
             const [maxDocPos] = await tx
               .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
               .from(schema.documents)

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

@@ -398,6 +398,7 @@ export default defineAction({
 
       const secondaryId = await insertSecondarySource({
         database,
+        expectedPrimarySourceId: existingSource.id,
         sourceType,
         sourceName,
         sourceTable,
@@ -491,6 +492,7 @@ export default defineAction({
         additionalRead.state === "live" ? additionalRead.entries : [];
       const additionalSourceId = await insertSecondarySource({
         database,
+        expectedPrimarySourceId: existingSource.id,
         sourceType,
         sourceName,
         sourceTable,

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, isNull, sql } from "drizzle-orm";
+import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -16,6 +16,8 @@ import {
   normalizePropertyVisibility,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
+import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
   propertyDefinitionsPositionScope,
   withPositionLock,
@@ -101,7 +103,7 @@ export default defineAction({
     const now = new Date().toISOString();
     const name = args.name.trim();
     const type = args.type as DocumentPropertyType;
-    let optionsJson = optionsForNewProperty(type, args.options as any);
+    const optionsJson = optionsForNewProperty(type, args.options as any);
     const database = await resolvePropertyDatabaseForDocument(
       document,
       args.databaseId,
@@ -114,13 +116,12 @@ export default defineAction({
     }
 
     if (args.id) {
-      const propertyId = args.id;
       const [existing] = await db
         .select()
         .from(schema.documentPropertyDefinitions)
         .where(
           and(
-            eq(schema.documentPropertyDefinitions.id, propertyId),
+            eq(schema.documentPropertyDefinitions.id, args.id),
             eq(
               schema.documentPropertyDefinitions.ownerEmail,
               document.ownerEmail,
@@ -128,95 +129,79 @@ export default defineAction({
             eq(schema.documentPropertyDefinitions.databaseId, database.id),
           ),
         );
-      if (!existing) throw new Error(`Property "${propertyId}" not found`);
-      if (existing.systemRole) {
-        throw new Error("System properties cannot be changed.");
-      }
-      if (
-        isComputedPropertyType(existing.type as DocumentPropertyType) &&
-        existing.type !== type
-      ) {
-        throw new Error("Computed property types cannot be changed.");
-      }
-
-      const existingOptions = parsePropertyOptions(existing.optionsJson);
-      const existingIsPrimaryBlocks =
-        isBlocksPropertyType(existing.type as DocumentPropertyType) &&
-        isPrimaryBlocksField(existingOptions);
-
-      // The primary "Content" Blocks field backs the document body — it can be
-      // renamed/hidden but not retyped (delete it from the database view to
-      // remove the body). Block the type switch defensively.
-      if (existingIsPrimaryBlocks && existing.type !== type) {
-        throw new Error(
-          "The primary Content (Blocks) field cannot change type. Delete it from the database view to remove the body.",
-        );
-      }
-
-      // Preserve the primary flag when re-saving the primary Blocks field (a
-      // rename or visibility change must NOT demote it to a normal Blocks field).
-      if (existingIsPrimaryBlocks && isBlocksPropertyType(type)) {
-        optionsJson = serializePropertyOptions({ blocks: { primary: true } });
-      }
-
+      if (!existing) throw new Error(`Property "${args.id}" not found`);
       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 [lockedExisting] = await tx
-          .update(schema.documentPropertyDefinitions)
-          .set({
-            updatedAt: sql`${schema.documentPropertyDefinitions.updatedAt}`,
-          })
+        await lockContentDatabaseMutation(
+          tx as unknown as ReturnType<typeof getDb>,
+          database.id,
+        );
+        let [lockedDefinition] = await tx
+          .select()
+          .from(schema.documentPropertyDefinitions)
           .where(
             and(
-              eq(schema.documentPropertyDefinitions.id, propertyId),
+              eq(schema.documentPropertyDefinitions.id, args.id!),
               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)
+          );
+        if (!lockedDefinition)
+          throw new Error(`Property "${args.id}" not found`);
+        if (lockedDefinition.systemRole) {
           throw new Error("System properties cannot be changed.");
+        }
         if (
-          isComputedPropertyType(lockedExisting.type as DocumentPropertyType) &&
-          lockedExisting.type !== type
+          isComputedPropertyType(
+            lockedDefinition.type as DocumentPropertyType,
+          ) &&
+          lockedDefinition.type !== type
         ) {
           throw new Error("Computed property types cannot be changed.");
         }
+
+        const lockedOptions = parsePropertyOptions(
+          lockedDefinition.optionsJson,
+        );
         const lockedIsPrimaryBlocks =
-          isBlocksPropertyType(lockedExisting.type as DocumentPropertyType) &&
-          isPrimaryBlocksField(
-            parsePropertyOptions(lockedExisting.optionsJson),
-          );
-        if (lockedIsPrimaryBlocks && lockedExisting.type !== type) {
+          isBlocksPropertyType(lockedDefinition.type as DocumentPropertyType) &&
+          isPrimaryBlocksField(lockedOptions);
+        if (lockedIsPrimaryBlocks && lockedDefinition.type !== type) {
           throw new Error(
             "The primary Content (Blocks) field cannot change type. Delete it from the database view to remove the body.",
           );
         }
-
-        if (lockedExisting.type !== type) {
+        if (lockedDefinition.type !== type) {
+          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),
+          );
+          [lockedDefinition] = await tx
+            .select()
+            .from(schema.documentPropertyDefinitions)
+            .where(
+              and(
+                eq(schema.documentPropertyDefinitions.id, args.id!),
+                eq(
+                  schema.documentPropertyDefinitions.ownerEmail,
+                  document.ownerEmail,
+                ),
+                eq(schema.documentPropertyDefinitions.databaseId, database.id),
+              ),
+            );
+          if (!lockedDefinition) {
+            throw new Error(`Property "${args.id}" not found`);
+          }
           const [mappedSourceField] = await tx
             .select({ id: schema.contentDatabaseSourceFields.id })
             .from(schema.contentDatabaseSourceFields)
-            .where(
-              eq(schema.contentDatabaseSourceFields.propertyId, propertyId),
-            )
+            .where(eq(schema.contentDatabaseSourceFields.propertyId, args.id!))
             .limit(1);
           if (mappedSourceField) {
             throw new Error(
@@ -227,7 +212,7 @@ export default defineAction({
             .delete(schema.documentPropertyValues)
             .where(
               and(
-                eq(schema.documentPropertyValues.propertyId, propertyId),
+                eq(schema.documentPropertyValues.propertyId, args.id!),
                 eq(
                   schema.documentPropertyValues.ownerEmail,
                   document.ownerEmail,
@@ -239,18 +224,19 @@ export default defineAction({
             .where(
               and(
                 eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
-                eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+                eq(schema.contentDatabaseItemKeyClaims.propertyId, args.id!),
               ),
             );
-          // Switching a Blocks field to another type drops its independent content.
           if (
-            isBlocksPropertyType(lockedExisting.type as DocumentPropertyType) &&
+            isBlocksPropertyType(
+              lockedDefinition.type as DocumentPropertyType,
+            ) &&
             !isBlocksPropertyType(type)
           ) {
             await tx
               .delete(schema.documentBlockFieldContents)
               .where(
-                eq(schema.documentBlockFieldContents.propertyId, propertyId),
+                eq(schema.documentBlockFieldContents.propertyId, args.id!),
               );
           }
         }
@@ -265,7 +251,7 @@ export default defineAction({
             type,
             visibility:
               args.visibility === undefined
-                ? normalizePropertyVisibility(lockedExisting.visibility)
+                ? normalizePropertyVisibility(lockedDefinition.visibility)
                 : normalizePropertyVisibility(args.visibility),
             optionsJson:
               lockedIsPrimaryBlocks && isBlocksPropertyType(type)
@@ -273,40 +259,49 @@ export default defineAction({
                 : optionsJson,
             updatedAt: now,
           })
-          .where(eq(schema.documentPropertyDefinitions.id, propertyId));
+          .where(eq(schema.documentPropertyDefinitions.id, args.id!));
       });
     } else {
       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) => {
+            await lockContentDatabaseMutation(
+              tx as unknown as ReturnType<typeof getDb>,
+              database.id,
             );
+            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,
+                  ),
+                ),
+              );
 
-          await db.insert(schema.documentPropertyDefinitions).values({
-            id: nanoid(),
-            ownerEmail: document.ownerEmail,
-            orgId: document.orgId ?? null,
-            databaseId: database.id,
-            name,
-            description: args.description?.trim() ?? "",
-            type,
-            visibility: normalizePropertyVisibility(args.visibility),
-            optionsJson,
-            position: (maxPos?.max ?? -1) + 1,
-            createdAt: now,
-            updatedAt: now,
+            await tx.insert(schema.documentPropertyDefinitions).values({
+              id: nanoid(),
+              ownerEmail: document.ownerEmail,
+              orgId: document.orgId ?? null,
+              databaseId: database.id,
+              name,
+              description: args.description?.trim() ?? "",
+              type,
+              visibility: normalizePropertyVisibility(args.visibility),
+              optionsJson,
+              position: (maxPos?.max ?? -1) + 1,
+              createdAt: now,
+              updatedAt: now,
+            });
           });
         },
       );