@agent-native/core 0.154.3 → 0.154.5

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

@@ -38,12 +38,17 @@ import {
   parsePropertyValue,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { deleteBlocksFieldIdentity } from "./_blocks-field-identity.js";
 import { favoriteDocumentIds } from "./_content-favorites.js";
 import {
   listContentOrganizationMemberships,
   normalizeContentSpaceEmail,
   resolveContentSpaceAccess,
 } from "./_content-space-access.js";
+import {
+  databaseRowRevision,
+  getDatabaseMutationContract,
+} from "./_database-row-mutation.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
 import {
   applyFederatedOverlayValues,
@@ -1049,6 +1054,21 @@ export async function getContentDatabasePageResponse(
         queued: bodyHydrationQueued,
       }),
       properties: propertiesByDocumentId.get(document.id) ?? [],
+      rowRevision: databaseRowRevision({
+        itemId: item.id,
+        documentId: document.id,
+        title: document.title,
+        values: (propertiesByDocumentId.get(document.id) ?? [])
+          .filter(
+            (property) =>
+              !isBlocksPropertyType(property.definition.type) &&
+              !isComputedPropertyType(property.definition.type),
+          )
+          .map((property) => ({
+            propertyId: property.definition.id,
+            value: property.value,
+          })),
+      }),
     });
   }
 
@@ -1194,6 +1214,26 @@ export async function getContentDatabaseResponse(
     sources: page.sources,
     pagination: page.pagination,
     tableQueryMode: page.tableQueryMode,
+    mutationContract:
+      page.databaseRecord.spaceId && !page.databaseRecord.systemRole
+        ? await getDatabaseMutationContract(
+            {
+              authorityScope: page.databaseRecord.orgId
+                ? {
+                    kind: "organization",
+                    id: page.databaseRecord.orgId,
+                  }
+                : {
+                    kind: "personal",
+                    id: page.databaseRecord.ownerEmail,
+                  },
+              spaceId: page.databaseRecord.spaceId,
+              databaseId: page.databaseRecord.id,
+              databaseDocumentId: page.databaseRecord.documentId,
+            },
+            { accessAlreadyResolved: true },
+          )
+        : undefined,
   };
 }
 
@@ -1417,15 +1457,21 @@ export async function deleteDatabaseDataForDocument(
       .from(schema.documentPropertyDefinitions)
       .where(eq(schema.documentPropertyDefinitions.databaseId, database.id));
 
-    for (const definition of definitions) {
+    const definitionIds = definitions.map((definition) => definition.id);
+    if (definitionIds.length > 0) {
+      await deleteBlocksFieldIdentity({ db, propertyIds: definitionIds });
       await db
         .delete(schema.documentPropertyValues)
-        .where(eq(schema.documentPropertyValues.propertyId, definition.id));
+        .where(
+          inArray(schema.documentPropertyValues.propertyId, definitionIds),
+        );
       // Independent Blocks-field content is keyed by property id; drop it so
       // deleting a database leaves no orphaned document_block_field_contents.
       await db
         .delete(schema.documentBlockFieldContents)
-        .where(eq(schema.documentBlockFieldContents.propertyId, definition.id));
+        .where(
+          inArray(schema.documentBlockFieldContents.propertyId, definitionIds),
+        );
     }
     const sources = await db
       .select({ id: schema.contentDatabaseSources.id })
@@ -1463,6 +1509,11 @@ export async function deleteDatabaseDataForDocument(
       .where(
         eq(schema.contentDatabaseMigrationReceipts.databaseId, database.id),
       );
+    await db
+      .delete(schema.contentDatabaseRowMutationReceipts)
+      .where(
+        eq(schema.contentDatabaseRowMutationReceipts.databaseId, database.id),
+      );
     await db
       .delete(schema.documentPropertyDefinitions)
       .where(eq(schema.documentPropertyDefinitions.databaseId, database.id));
@@ -1482,6 +1533,7 @@ export async function deleteDatabaseDataForDocument(
     db,
   );
   if (item) {
+    await deleteBlocksFieldIdentity({ db, documentId });
     await db
       .delete(schema.contentDatabaseItemKeyClaims)
       .where(eq(schema.contentDatabaseItemKeyClaims.documentId, documentId));

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,
@@ -58,7 +65,8 @@ type ContentDatabaseSummaryRow = Pick<
   | "viewConfigJson"
   | "createdAt"
   | "updatedAt"
->;
+> &
+  Partial<Pick<ContentDatabaseRow, "spaceId" | "naturalKeyPropertyId">>;
 type ContentDatabaseItemRow = InferSelectModel<
   typeof schema.contentDatabaseItems
 >;
@@ -192,8 +200,10 @@ export function serializeDatabase(
   return {
     id: database.id,
     documentId: database.documentId,
+    spaceId: database.spaceId,
     title: database.title,
     systemRole: database.systemRole,
+    naturalKeyPropertyId: database.naturalKeyPropertyId,
     description,
     viewConfig: parseDatabaseViewConfig(database.viewConfigJson),
     createdAt: database.createdAt,
@@ -506,6 +516,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 +588,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 +644,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 +802,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/add-database-item.ts

@@ -1,255 +1,77 @@
 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, inArray, isNull, sql } from "drizzle-orm";
+import { buildDeepLink } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDb, schema } from "../server/db/index.js";
+import type { ContentDatabaseRowMutationResult } from "../shared/api.js";
 import {
-  isComputedPropertyType,
-  type DocumentPropertyType,
-} from "../shared/properties.js";
-import {
-  lockContentDatabaseMutation,
-  touchContentDatabase,
-} from "./_content-database-mutation-lock.js";
-import { ensureDocumentFilesMembership } from "./_content-files.js";
+  createDatabaseRow,
+  databaseMutationEnvelopeSchema,
+} from "./_database-row-mutation.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
-import {
-  databaseItemsPositionScope,
-  documentsPositionScope,
-  withPositionLock,
-} from "./_position-utils.js";
-import { nanoid, normalizedValueJson } from "./_property-utils.js";
 
-export default defineAction({
-  description: "Add a page item to a content database table.",
-  schema: z.object({
-    databaseId: z.string().describe("Database ID"),
-    title: z.string().optional().describe("New row page title"),
-    propertyValues: z
-      .record(z.string(), z.unknown())
-      .optional()
-      .describe("Initial property values keyed by property definition ID"),
-  }),
-  run: async ({ databaseId, title, propertyValues }) => {
-    const db = getDb();
-    const [database] = await db
-      .select()
-      .from(schema.contentDatabases)
-      .where(
-        and(
-          eq(schema.contentDatabases.id, databaseId),
-          isNull(schema.contentDatabases.deletedAt),
-        ),
-      );
-    if (!database) throw new Error(`Database "${databaseId}" not found`);
-    if (database.systemRole === "workspaces") {
-      throw new Error("Use create-content-space to add a workspace");
-    }
+const schema = databaseMutationEnvelopeSchema.extend({
+  title: z
+    .string()
+    .trim()
+    .min(1)
+    .max(500)
+    .optional()
+    .describe("New row page title"),
+  propertyValues: z
+    .record(z.string(), z.unknown())
+    .optional()
+    .describe("Strict property values keyed by property definition ID"),
+});
 
-    const access = await assertAccess(
-      "document",
-      database.documentId,
-      "editor",
+export default defineAction({
+  description:
+    "Create one row in an exact ordinary Content database using its discovered schema revision. Strictly validates every non-Blocks property, applies the side effect once per idempotency key, and returns a verified receipt with stable row identity.",
+  schema,
+  audit: {
+    recordInputs: false,
+    target: (args) => ({
+      type: "content-database",
+      id: args.target.databaseId,
+      visibility: "private",
+    }),
+    summary: (_args, result) => {
+      const receipt = (result as ContentDatabaseRowMutationResult | null)
+        ?.receipt;
+      return receipt
+        ? `Created Content database row ${receipt.row.itemId}`
+        : "Created Content database row";
+    },
+  },
+  run: async (args): Promise<ContentDatabaseRowMutationResult> => {
+    const result = await createDatabaseRow(args);
+    const response = await getContentDatabaseResponse(
+      result.receipt.target.databaseId,
+      {
+        limit: 1,
+        offset: 0,
+        documentIds: [result.receipt.row.documentId],
+      },
     );
-    const databaseDocument = access.resource;
-    if (
-      database.spaceId &&
-      databaseDocument.spaceId &&
-      databaseDocument.spaceId !== database.spaceId
-    ) {
+    const createdItem = response.items[0];
+    if (!createdItem || createdItem.id !== result.receipt.row.itemId) {
       throw new Error(
-        `Database "${databaseId}" has inconsistent Content space`,
+        "Created row receipt did not resolve to its exact read-back.",
       );
     }
-    const now = new Date().toISOString();
-    const databaseSpaceId =
-      database.spaceId ?? (databaseDocument.spaceId as string | null);
-    if (!databaseSpaceId) {
-      throw new Error("Database does not belong to a Content space.");
-    }
-    if (databaseSpaceId && (!database.spaceId || !databaseDocument.spaceId)) {
-      await db.transaction(async (tx) => {
-        if (!database.spaceId) {
-          await tx
-            .update(schema.contentDatabases)
-            .set({ spaceId: databaseSpaceId, updatedAt: now })
-            .where(eq(schema.contentDatabases.id, databaseId));
-        }
-        if (!databaseDocument.spaceId) {
-          await tx
-            .update(schema.documents)
-            .set({ spaceId: databaseSpaceId, updatedAt: now })
-            .where(eq(schema.documents.id, database.documentId));
-        }
-        await ensureDocumentFilesMembership(tx, database.documentId, now);
-      });
-    }
-
-    const documentId = nanoid();
-    const itemId = nanoid();
-
-    const inheritedShares = await db
-      .select({
-        principalType: schema.documentShares.principalType,
-        principalId: schema.documentShares.principalId,
-        role: schema.documentShares.role,
-      })
-      .from(schema.documentShares)
-      .where(eq(schema.documentShares.resourceId, database.documentId));
-
-    const initialValues = Object.entries(propertyValues ?? {});
-
-    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)
-              .where(
-                and(
-                  eq(schema.documents.ownerEmail, database.ownerEmail),
-                  eq(schema.documents.parentId, database.documentId),
-                ),
-              );
-            const [maxItemPos] = await tx
-              .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
-              .from(schema.contentDatabaseItems)
-              .where(eq(schema.contentDatabaseItems.databaseId, databaseId));
-
-            await tx.insert(schema.documents).values({
-              id: documentId,
-              spaceId: databaseSpaceId,
-              ownerEmail: database.ownerEmail,
-              orgId: database.orgId,
-              parentId: database.documentId,
-              title: title?.trim() ?? "",
-              content: "",
-              icon: null,
-              position: (maxDocPos?.max ?? -1) + 1,
-              isFavorite: 0,
-              hideFromSearch: databaseDocument.hideFromSearch ?? 0,
-              visibility: databaseDocument.visibility ?? "private",
-              createdAt: now,
-              updatedAt: now,
-            });
-            await tx.insert(schema.contentDatabaseItems).values({
-              id: itemId,
-              ownerEmail: database.ownerEmail,
-              orgId: database.orgId,
-              databaseId,
-              documentId,
-              position: (maxItemPos?.max ?? -1) + 1,
-              createdAt: now,
-              updatedAt: now,
-            });
-            if (inheritedShares.length > 0) {
-              await tx.insert(schema.documentShares).values(
-                inheritedShares.map((share) => ({
-                  id: nanoid(),
-                  resourceId: documentId,
-                  principalType: share.principalType,
-                  principalId: share.principalId,
-                  role: share.role,
-                  createdBy: getRequestUserEmail() ?? database.ownerEmail,
-                  createdAt: now,
-                })),
-              );
-            }
-            if (propertyValueRows.length > 0) {
-              await tx
-                .insert(schema.documentPropertyValues)
-                .values(propertyValueRows);
-            }
-            await ensureDocumentFilesMembership(tx, documentId, now);
-          });
-        }),
-    );
-
-    await writeAppState("refresh-signal", { ts: Date.now() }).catch(() => {
-      // The row is already committed; polling will reconcile if a concurrent
-      // SQLite writer briefly blocks this best-effort refresh hint.
-    });
-
-    const response = await getContentDatabaseResponse(databaseId, {
-      limit: 100,
-      offset: 0,
-    });
-    const createdItem =
-      response.items.find((item) => item.id === itemId) ??
-      (
-        await getContentDatabaseResponse(databaseId, {
-          limit: 1,
-          offset: 0,
-          documentIds: [documentId],
-        })
-      ).items.find((item) => item.id === itemId);
+    return { ...result, createdItem };
+  },
+  link: ({ result }) => {
+    const documentId = (result as ContentDatabaseRowMutationResult | null)
+      ?.receipt.row.documentId;
+    if (!documentId) return null;
     return {
-      ...response,
-      createdItem,
-      createdItemId: itemId,
-      createdDocumentId: documentId,
-      createdDocumentUpdatedAt: now,
+      url: buildDeepLink({
+        app: "content",
+        view: "editor",
+        params: { documentId },
+      }),
+      label: "Open database row",
+      view: "editor",
     };
   },
 });