@agent-native/core 0.154.3 → 0.154.5

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,
@@ -166,7 +226,10 @@ export default defineAction({
         database.id,
       );
       const [lockedDatabase] = await tx
-        .select({ id: schema.contentDatabases.id })
+        .select({
+          id: schema.contentDatabases.id,
+          naturalKeyPropertyId: schema.contentDatabases.naturalKeyPropertyId,
+        })
         .from(schema.contentDatabases)
         .where(
           and(
@@ -212,6 +275,41 @@ export default defineAction({
       if (isComputedPropertyType(lockedType)) {
         throw new Error("Computed properties cannot be edited.");
       }
+      const isNaturalKey = lockedDatabase.naturalKeyPropertyId === propertyId;
+      if (isNaturalKey) {
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(valueJson);
+        } catch {
+          parsed = null;
+        }
+        if (typeof parsed !== "string" || !parsed.trim()) {
+          throw new Error(
+            "A database natural key must remain a non-empty string.",
+          );
+        }
+        const [existingNaturalKeyClaim] = await tx
+          .select({
+            keyValueJson: schema.contentDatabaseItemKeyClaims.keyValueJson,
+          })
+          .from(schema.contentDatabaseItemKeyClaims)
+          .where(
+            and(
+              eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+              eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+              eq(schema.contentDatabaseItemKeyClaims.documentId, documentId),
+            ),
+          )
+          .limit(1);
+        if (
+          existingNaturalKeyClaim &&
+          existingNaturalKeyClaim.keyValueJson !== valueJson
+        ) {
+          throw new Error(
+            "A claimed database natural key cannot be changed. Create a new row instead.",
+          );
+        }
+      }
       const [conflictingClaim] = await tx
         .select({ id: schema.contentDatabaseItemKeyClaims.id })
         .from(schema.contentDatabaseItemKeyClaims)
@@ -254,6 +352,45 @@ export default defineAction({
           updatedAt: now,
         });
       }
+      if (isNaturalKey) {
+        await tx
+          .insert(schema.contentDatabaseItemKeyClaims)
+          .values({
+            id: nanoid(),
+            ownerEmail: database.ownerEmail,
+            orgId: database.orgId,
+            databaseId: database.id,
+            propertyId,
+            keyValueJson: valueJson,
+            itemId: membership.id,
+            documentId,
+            createdAt: now,
+            updatedAt: now,
+          })
+          .onConflictDoNothing();
+        const [claim] = await tx
+          .select({
+            itemId: schema.contentDatabaseItemKeyClaims.itemId,
+            documentId: schema.contentDatabaseItemKeyClaims.documentId,
+          })
+          .from(schema.contentDatabaseItemKeyClaims)
+          .where(
+            and(
+              eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+              eq(schema.contentDatabaseItemKeyClaims.propertyId, propertyId),
+              eq(schema.contentDatabaseItemKeyClaims.keyValueJson, valueJson),
+            ),
+          );
+        if (
+          !claim ||
+          claim.itemId !== membership.id ||
+          claim.documentId !== documentId
+        ) {
+          throw new Error(
+            "This natural key is already claimed by another database row.",
+          );
+        }
+      }
       await tx
         .delete(schema.contentDatabaseItemKeyClaims)
         .where(

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

@@ -0,0 +1,62 @@
+import { defineAction } from "@agent-native/core";
+import { buildDeepLink } from "@agent-native/core/server";
+import { z } from "zod";
+
+import type { ContentDatabaseRowMutationResult } from "../shared/api.js";
+import {
+  databaseMutationEnvelopeSchema,
+  updateDatabaseRow,
+} from "./_database-row-mutation.js";
+
+const schema = databaseMutationEnvelopeSchema.extend({
+  itemId: z.string().min(1).describe("Exact database membership row ID"),
+  documentId: z.string().min(1).describe("Exact row page ID"),
+  expectedRowRevision: z
+    .string()
+    .min(1)
+    .describe("Row revision returned by get-content-database"),
+  title: z.string().trim().min(1).max(500).optional(),
+  propertyValues: z
+    .record(z.string(), z.unknown())
+    .optional()
+    .describe(
+      "Sparse strict patch keyed by property definition ID; omitted fields are preserved and explicit null clears a value",
+    ),
+});
+
+export default defineAction({
+  description:
+    "Sparsely update one exact Content database row by stable item and document IDs. Requires schema and row revisions, validates every non-Blocks property, and returns a verified idempotent receipt.",
+  schema,
+  http: { method: "PUT" },
+  audit: {
+    recordInputs: false,
+    target: (args) => ({
+      type: "document",
+      id: args.documentId,
+      visibility: "private",
+    }),
+    summary: (_args, result) => {
+      const receipt = (result as ContentDatabaseRowMutationResult | null)
+        ?.receipt;
+      return receipt
+        ? `${receipt.outcome === "unchanged" ? "Checked" : "Updated"} Content database row ${receipt.row.itemId}`
+        : "Updated Content database row";
+    },
+  },
+  run: updateDatabaseRow,
+  link: ({ result }) => {
+    const documentId = (result as ContentDatabaseRowMutationResult | null)
+      ?.receipt.row.documentId;
+    if (!documentId) return null;
+    return {
+      url: buildDeepLink({
+        app: "content",
+        view: "editor",
+        params: { documentId },
+      }),
+      label: "Open database row",
+      view: "editor",
+    };
+  },
+});

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