@agent-native/core 0.154.2 → 0.154.4

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

@@ -1,10 +1,15 @@
-import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import {
+  accessFilter,
+  assertAccess,
+  resolveAccess,
+} from "@agent-native/core/sharing";
 import {
   and,
   asc,
   eq,
   inArray,
   isNull,
+  or,
   sql,
   type InferSelectModel,
 } from "drizzle-orm";
@@ -21,6 +26,7 @@ import type {
   ContentDatabaseOpenPagesIn,
   DocumentProperty,
 } from "../shared/api.js";
+import { blocksFieldId } from "../shared/blocks-field-identity.js";
 import {
   DEFAULT_BLOCKS_FIELD_NAME,
   defaultPropertyOptions,
@@ -42,6 +48,7 @@ import {
   type DocumentPropertyValue,
 } from "../shared/properties.js";
 import { chunks } from "./_batch-utils.js";
+import { readBlocksFieldIdentities } from "./_blocks-field-identity.js";
 import {
   propertyDefinitionsPositionScope,
   withPositionLock,
@@ -506,6 +513,44 @@ export async function listPropertiesForDocument(
   return listPropertiesForDatabase(database.id, document);
 }
 
+export async function listPropertiesForAllDocumentDatabases(
+  document: DocumentRow,
+) {
+  const db = getDb();
+  const memberships = await db
+    .select({ databaseId: schema.contentDatabaseItems.databaseId })
+    .from(schema.contentDatabaseItems)
+    .where(eq(schema.contentDatabaseItems.documentId, document.id));
+  const membershipIds = memberships.map((membership) => membership.databaseId);
+  const databases = await db
+    .select({
+      id: schema.contentDatabases.id,
+      documentId: schema.contentDatabases.documentId,
+    })
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        isNull(schema.contentDatabases.deletedAt),
+        membershipIds.length > 0
+          ? or(
+              eq(schema.contentDatabases.documentId, document.id),
+              inArray(schema.contentDatabases.id, membershipIds),
+            )
+          : eq(schema.contentDatabases.documentId, document.id),
+      ),
+    )
+    .orderBy(asc(schema.contentDatabases.id));
+
+  const properties = [];
+  for (const database of databases) {
+    if (!(await resolveAccess("document", database.documentId))) continue;
+    properties.push(
+      ...(await listPropertiesForDatabase(database.id, document)),
+    );
+  }
+  return properties;
+}
+
 export async function listPropertiesForDatabase(
   databaseId: string,
   valueDocument?: DocumentRow,
@@ -540,10 +585,46 @@ export async function listPropertiesForDatabase(
     ? await blockFieldContentsForDocument(valueDocument.id)
     : new Map<string, string>();
 
+  const blocksFieldIdentityById = valueDocument
+    ? await readBlocksFieldIdentities({
+        db,
+        fields: definitions.flatMap((definition) => {
+          const type = definition.type as DocumentPropertyType;
+          if (!isBlocksPropertyType(type)) return [];
+          const options = parsePropertyOptions(definition.optionsJson);
+          return [
+            {
+              documentId: valueDocument.id,
+              propertyId: definition.id,
+              markdown: resolveBlocksFieldValue({
+                options,
+                documentBody: valueDocument.content,
+                blockFieldContent: blockContentByPropertyId.get(definition.id),
+              }),
+            },
+          ];
+        }),
+      })
+    : new Map();
+
   const properties = definitions.map((definition) => {
     const type = definition.type as DocumentPropertyType;
     const storedValue = valueByPropertyId.get(definition.id);
     const options = parsePropertyOptions(definition.optionsJson);
+    const value =
+      valueDocument && isComputedPropertyType(type) && type !== "formula"
+        ? computedPropertyValue(type, valueDocument, {
+            databaseRowNumber: rowNumberByDocumentId.get(valueDocument.id),
+          })
+        : valueDocument && isBlocksPropertyType(type)
+          ? // Each Blocks field reads from exactly one place: the primary from
+            // the document body, additional fields from their own store.
+            resolveBlocksFieldValue({
+              options,
+              documentBody: valueDocument.content,
+              blockFieldContent: blockContentByPropertyId.get(definition.id),
+            })
+          : parsePropertyValue(storedValue?.valueJson);
     return {
       definition: {
         id: definition.id,
@@ -560,21 +641,15 @@ export async function listPropertiesForDatabase(
         createdAt: definition.createdAt,
         updatedAt: definition.updatedAt,
       },
-      value:
-        valueDocument && isComputedPropertyType(type) && type !== "formula"
-          ? computedPropertyValue(type, valueDocument, {
-              databaseRowNumber: rowNumberByDocumentId.get(valueDocument.id),
-            })
-          : valueDocument && isBlocksPropertyType(type)
-            ? // Each Blocks field reads from exactly one place: the primary from
-              // the document body, additional fields from their own store.
-              resolveBlocksFieldValue({
-                options,
-                documentBody: valueDocument.content,
-                blockFieldContent: blockContentByPropertyId.get(definition.id),
-              })
-            : parsePropertyValue(storedValue?.valueJson),
+      value,
       editable: !definition.systemRole && !isComputedPropertyType(type),
+      ...(valueDocument && isBlocksPropertyType(type)
+        ? {
+            blocksField: blocksFieldIdentityById.get(
+              blocksFieldId(valueDocument.id, definition.id),
+            ),
+          }
+        : {}),
     };
   });
 
@@ -724,32 +799,64 @@ export async function listPropertiesForDatabaseDocuments(
     }
   }
 
+  const blocksFieldIdentityById = await readBlocksFieldIdentities({
+    db,
+    fields: valueDocuments.flatMap((document) =>
+      definitions.flatMap((definition) => {
+        const type = definition.type as DocumentPropertyType;
+        if (!isBlocksPropertyType(type)) return [];
+        const options = parsePropertyOptions(definition.optionsJson);
+        return [
+          {
+            documentId: document.id,
+            propertyId: definition.id,
+            markdown: resolveBlocksFieldValue({
+              options,
+              documentBody: document.content,
+              blockFieldContent: blockContentByDocumentAndProperty.get(
+                propertyValueKey(document.id, definition.id),
+              ),
+            }),
+          },
+        ];
+      }),
+    ),
+  });
+
   for (const document of valueDocuments) {
     const properties = definitions.map((definition) => {
       const propertyDefinition = serializePropertyDefinition(definition);
       const storedValue = valueByDocumentAndProperty.get(
         propertyValueKey(document.id, definition.id),
       );
+      const value =
+        isComputedPropertyType(propertyDefinition.type) &&
+        propertyDefinition.type !== "formula"
+          ? computedPropertyValue(propertyDefinition.type, document, {
+              databaseRowNumber: rowNumberByDocumentId.get(document.id),
+            })
+          : isBlocksPropertyType(propertyDefinition.type)
+            ? resolveBlocksFieldValue({
+                options: propertyDefinition.options,
+                documentBody: document.content,
+                blockFieldContent: blockContentByDocumentAndProperty.get(
+                  propertyValueKey(document.id, definition.id),
+                ),
+              })
+            : parsePropertyValue(storedValue?.valueJson);
       return {
         definition: propertyDefinition,
-        value:
-          isComputedPropertyType(propertyDefinition.type) &&
-          propertyDefinition.type !== "formula"
-            ? computedPropertyValue(propertyDefinition.type, document, {
-                databaseRowNumber: rowNumberByDocumentId.get(document.id),
-              })
-            : isBlocksPropertyType(propertyDefinition.type)
-              ? resolveBlocksFieldValue({
-                  options: propertyDefinition.options,
-                  documentBody: document.content,
-                  blockFieldContent: blockContentByDocumentAndProperty.get(
-                    propertyValueKey(document.id, definition.id),
-                  ),
-                })
-              : parsePropertyValue(storedValue?.valueJson),
+        value,
         editable:
           !definition.systemRole &&
           !isComputedPropertyType(propertyDefinition.type),
+        ...(isBlocksPropertyType(propertyDefinition.type)
+          ? {
+              blocksField: blocksFieldIdentityById.get(
+                blocksFieldId(document.id, definition.id),
+              ),
+            }
+          : {}),
       };
     });
 

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

@@ -16,6 +16,7 @@ import {
   normalizePropertyVisibility,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { deleteBlocksFieldIdentity } from "./_blocks-field-identity.js";
 import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
@@ -233,6 +234,10 @@ export default defineAction({
             ) &&
             !isBlocksPropertyType(type)
           ) {
+            await deleteBlocksFieldIdentity({
+              db: tx as unknown as ReturnType<typeof getDb>,
+              propertyId: args.id!,
+            });
             await tx
               .delete(schema.documentBlockFieldContents)
               .where(

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

@@ -11,6 +11,10 @@ import {
   parsePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import {
+  deleteBlocksFieldIdentity,
+  lockPrimaryBlocksFieldsForDocuments,
+} from "./_blocks-field-identity.js";
 import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import { lockDatabaseMemberships } from "./_database-membership-lock.js";
 import {
@@ -65,14 +69,6 @@ export default defineAction({
         tx as unknown as ReturnType<typeof getDb>,
         database.id,
       );
-      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),
-      );
       const [lockedDefinition] = await tx
         .select()
         .from(schema.documentPropertyDefinitions)
@@ -100,6 +96,25 @@ export default defineAction({
         isPrimaryBlocksField(
           parsePropertyOptions(lockedDefinition.optionsJson),
         );
+      const items = await tx
+        .select({
+          id: schema.contentDatabaseItems.id,
+          documentId: schema.contentDatabaseItems.documentId,
+        })
+        .from(schema.contentDatabaseItems)
+        .where(eq(schema.contentDatabaseItems.databaseId, database.id));
+      const primaryFieldsByDocument = isPrimaryBlocks
+        ? await lockPrimaryBlocksFieldsForDocuments(
+            tx as unknown as ReturnType<typeof getDb>,
+            items.map((item) => item.documentId),
+          )
+        : new Map();
+      if (!isPrimaryBlocks) {
+        await lockDatabaseMemberships(
+          tx,
+          items.map((item) => item.id),
+        );
+      }
 
       await tx
         .delete(schema.documentPropertyValues)
@@ -117,6 +132,10 @@ export default defineAction({
         .where(eq(schema.documentPropertyDefinitions.id, propertyId));
 
       if (isBlocks) {
+        await deleteBlocksFieldIdentity({
+          db: tx as unknown as ReturnType<typeof getDb>,
+          propertyId,
+        });
         await tx
           .delete(schema.documentBlockFieldContents)
           .where(eq(schema.documentBlockFieldContents.propertyId, propertyId));
@@ -130,20 +149,22 @@ export default defineAction({
             })
             .where(eq(schema.contentDatabases.id, database.id));
 
-          const items = await tx
-            .select({ documentId: schema.contentDatabaseItems.documentId })
-            .from(schema.contentDatabaseItems)
-            .where(eq(schema.contentDatabaseItems.databaseId, database.id));
-          if (items.length > 0) {
+          const documentsWithoutSurvivingPrimary = items
+            .filter(
+              (item) =>
+                !(primaryFieldsByDocument.get(item.documentId) ?? []).some(
+                  (field: { propertyId: string }) =>
+                    field.propertyId !== propertyId,
+                ),
+            )
+            .map((item) => item.documentId);
+          if (documentsWithoutSurvivingPrimary.length > 0) {
             const now = new Date().toISOString();
             await tx
               .update(schema.documents)
               .set({ content: "", updatedAt: now })
               .where(
-                inArray(
-                  schema.documents.id,
-                  items.map((item) => item.documentId),
-                ),
+                inArray(schema.documents.id, documentsWithoutSurvivingPrimary),
               );
           }
         }

package/corpus/templates/content/actions/delete-document.ts

@@ -6,6 +6,7 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { chunks } from "./_batch-utils.js";
+import { deleteBlocksFieldIdentity } from "./_blocks-field-identity.js";
 import {
   lockContentDatabaseMutation,
   touchContentDatabase,
@@ -695,6 +696,7 @@ async function deleteCollectedDocuments(
   });
 
   await deleteWhereIn(propertyDefinitionIds, async (propertyIdBatch) => {
+    await deleteBlocksFieldIdentity({ db, propertyIds: propertyIdBatch });
     await db
       .delete(schema.documentPropertyValues)
       .where(
@@ -730,6 +732,7 @@ async function deleteCollectedDocuments(
   });
 
   await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await deleteBlocksFieldIdentity({ db, documentIds: documentIdBatch });
     await db
       .delete(schema.contentDatabaseBodyHydrationQueue)
       .where(

package/corpus/templates/content/actions/edit-document.ts

@@ -17,6 +17,10 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import {
+  lockPrimaryBlocksFields,
+  persistBlocksFieldIdentity,
+} from "./_blocks-field-identity.js";
 
 interface TextEdit {
   find: string;
@@ -235,11 +239,24 @@ export default defineAction({
     // Persist. The fresh updatedAt is the signal the open editor uses to tell an
     // intentional external edit apart from a stale autosave echo.
     const db = getDb();
+    const now = new Date().toISOString();
     await db.transaction(async (tx: any) => {
+      const primaryBlocksFields = await lockPrimaryBlocksFields(tx, id);
       await tx
         .update(schema.documents)
-        .set({ content, updatedAt: new Date().toISOString() })
+        .set({ content, updatedAt: now })
         .where(eq(schema.documents.id, id));
+      for (const field of primaryBlocksFields) {
+        await persistBlocksFieldIdentity({
+          db: tx as unknown as ReturnType<typeof getDb>,
+          ownerEmail: field.ownerEmail,
+          documentId: id,
+          propertyId: field.propertyId,
+          previousMarkdown: existing.content ?? "",
+          markdown: content,
+          now,
+        });
+      }
       if (creativeContext) {
         await recordGenerationCreativeContext(
           {

package/corpus/templates/content/actions/export-document.ts

@@ -3,8 +3,14 @@ import { buildDeepLink } from "@agent-native/core/server";
 import { resolveAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
+import { blocksContentHash } from "../shared/blocks-field-identity.js";
 import { buildDocumentExport } from "../shared/document-export.js";
+import {
+  isBlocksPropertyType,
+  isPrimaryBlocksField,
+} from "../shared/properties.js";
 import "../server/db/index.js";
+import { listPropertiesForAllDocumentDatabases } from "./_property-utils.js";
 
 export default defineAction({
   description:
@@ -33,12 +39,47 @@ export default defineAction({
     if (!access) throw new Error(`Document "${id}" not found`);
 
     const doc = access.resource;
+    const properties = await listPropertiesForAllDocumentDatabases(doc);
+    const blocksFields = properties
+      .filter((property) => isBlocksPropertyType(property.definition.type))
+      .map((property) => {
+        if (!property.definition.databaseId) {
+          throw new Error(
+            `Blocks field "${property.definition.id}" is not attached to a database`,
+          );
+        }
+        if (!property.blocksField) {
+          throw new Error(
+            `Blocks field "${property.definition.id}" has no identity state`,
+          );
+        }
+        const markdown =
+          content !== undefined &&
+          isPrimaryBlocksField(property.definition.options)
+            ? content
+            : typeof property.value === "string"
+              ? property.value
+              : "";
+        const identity =
+          blocksContentHash(markdown) === property.blocksField.contentHash
+            ? property.blocksField
+            : { ...property.blocksField, identityStatus: "stale" as const };
+        return {
+          databaseId: property.definition.databaseId,
+          propertyId: property.definition.id,
+          name: property.definition.name,
+          position: property.definition.position,
+          markdown,
+          identity,
+        };
+      });
     const payload = buildDocumentExport({
       id: doc.id,
       title: title ?? doc.title,
       content: content ?? doc.content,
       updatedAt: doc.updatedAt,
       format,
+      blocksFields,
     });
 
     return {

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

@@ -4,6 +4,7 @@ import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, inArray } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
+import { deleteBlocksFieldIdentity } from "./_blocks-field-identity.js";
 import {
   lockContentDatabaseMutation,
   touchContentDatabase,
@@ -132,6 +133,15 @@ export default defineAction({
             )
         ).map((property) => property.id);
         if (removedDocumentIds.length > 0 && propertyIds.length > 0) {
+          for (const removedDocumentId of removedDocumentIds) {
+            for (const propertyId of propertyIds) {
+              await deleteBlocksFieldIdentity({
+                db: tx as unknown as ReturnType<typeof getDb>,
+                documentId: removedDocumentId,
+                propertyId,
+              });
+            }
+          }
           await tx
             .delete(schema.documentPropertyValues)
             .where(

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

@@ -12,6 +12,10 @@ import {
   parsePropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import {
+  lockPrimaryBlocksFields,
+  persistBlocksFieldIdentity,
+} from "./_blocks-field-identity.js";
 import { lockContentDatabaseMutation } from "./_content-database-mutation-lock.js";
 import { resolveContentDocumentAccess } from "./_content-document-access.js";
 import { lockDatabaseMemberships } from "./_database-membership-lock.js";
@@ -34,8 +38,15 @@ export default defineAction({
       ),
     propertyId: z.string().describe("Property definition ID"),
     value: z.unknown().describe("Value for the property type"),
+    expectedBlocksFieldRevision: z.number().int().nonnegative().optional(),
   }),
-  run: async ({ documentId, databaseId, propertyId, value }) => {
+  run: async ({
+    documentId,
+    databaseId,
+    propertyId,
+    value,
+    expectedBlocksFieldRevision,
+  }) => {
     const db = getDb();
     const [definition] = await db
       .select()
@@ -85,7 +96,10 @@ export default defineAction({
         parsePropertyOptions(definition.optionsJson),
       );
       await db.transaction(async (tx) => {
-        await lockDatabaseMemberships(tx, [membership.id]);
+        const primaryBlocksFields = await lockPrimaryBlocksFields(
+          tx as unknown as ReturnType<typeof getDb>,
+          documentId,
+        );
         const [lockedDefinition] = await tx
           .select()
           .from(schema.documentPropertyDefinitions)
@@ -116,12 +130,31 @@ export default defineAction({
         target = blocksStorageTarget(
           parsePropertyOptions(lockedDefinition.optionsJson),
         );
+        let previousContent = "";
         if (target === "document_body") {
+          const [currentDocument] = await tx
+            .select({ content: schema.documents.content })
+            .from(schema.documents)
+            .where(eq(schema.documents.id, documentId));
+          if (!currentDocument) {
+            throw new Error(`Document "${documentId}" not found`);
+          }
+          previousContent = currentDocument.content;
           await tx
             .update(schema.documents)
             .set({ content, updatedAt: now })
             .where(eq(schema.documents.id, documentId));
         } else {
+          const [currentField] = await tx
+            .select({ content: schema.documentBlockFieldContents.content })
+            .from(schema.documentBlockFieldContents)
+            .where(
+              and(
+                eq(schema.documentBlockFieldContents.documentId, documentId),
+                eq(schema.documentBlockFieldContents.propertyId, propertyId),
+              ),
+            );
+          previousContent = currentField?.content ?? "";
           await tx
             .insert(schema.documentBlockFieldContents)
             .values({
@@ -141,6 +174,33 @@ export default defineAction({
               set: { content, updatedAt: now },
             });
         }
+        const identityFields =
+          target === "document_body"
+            ? primaryBlocksFields
+            : [{ propertyId, ownerEmail: database.ownerEmail }];
+        if (
+          target === "document_body" &&
+          !identityFields.some((field) => field.propertyId === propertyId)
+        ) {
+          throw new Error(
+            "Primary Blocks membership changed before the operation completed.",
+          );
+        }
+        for (const field of identityFields) {
+          await persistBlocksFieldIdentity({
+            db: tx as unknown as ReturnType<typeof getDb>,
+            ownerEmail: field.ownerEmail,
+            documentId,
+            propertyId: field.propertyId,
+            previousMarkdown: previousContent,
+            markdown: content,
+            expectedRevision:
+              field.propertyId === propertyId
+                ? expectedBlocksFieldRevision
+                : undefined,
+            now,
+          });
+        }
       });
       return {
         documentId,

package/corpus/templates/content/actions/update-document.ts

@@ -19,6 +19,10 @@ import {
   parseDocumentHideFromSearch,
 } from "../server/lib/documents.js";
 import type { DocumentUpdateResponse } from "../shared/api.js";
+import {
+  lockPrimaryBlocksFields,
+  persistBlocksFieldIdentity,
+} from "./_blocks-field-identity.js";
 import { BUILDER_CMS_BODY_CONTENT_KEY } from "./_builder-cms-source-adapter.js";
 import { reconcileInlineDatabasesForDocument } from "./_content-database-lifecycle.js";
 import { resolveContentDocumentAccess } from "./_content-document-access.js";
@@ -510,6 +514,12 @@ export default defineAction({
       if (iconChanged) updates.icon = args.icon;
       let contentCasConflict = false;
       await db.transaction(async (tx) => {
+        const primaryBlocksFields = contentChanged
+          ? await lockPrimaryBlocksFields(
+              tx as unknown as ReturnType<typeof getDb>,
+              id,
+            )
+          : [];
         if (useContentCas) {
           const applied = await tx
             .update(schema.documents)
@@ -532,6 +542,20 @@ export default defineAction({
             .where(eq(schema.documents.id, id));
         }
 
+        if (contentChanged && content !== undefined) {
+          for (const field of primaryBlocksFields) {
+            await persistBlocksFieldIdentity({
+              db: tx as unknown as ReturnType<typeof getDb>,
+              ownerEmail: field.ownerEmail,
+              documentId: id,
+              propertyId: field.propertyId,
+              previousMarkdown: existing.content,
+              markdown: content,
+              now: updates.updatedAt as string,
+            });
+          }
+        }
+
         if (titleChanged || contentChanged) {
           const [latestVersion] = await tx
             .select({ createdAt: schema.documentVersions.createdAt })