@agent-native/core 0.91.1 → 0.92.0

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

@@ -16,6 +16,7 @@ import {
   federateSources,
 } from "./_federation-join.js";
 import {
+  listPropertiesForDatabaseDocuments,
   listPropertiesForDatabase,
   serializeDatabase,
 } from "./_property-utils.js";
@@ -197,6 +198,10 @@ export async function getContentDatabaseResponse(
           )
       : [];
   const documentById = new Map(documents.map((doc) => [doc.id, doc]));
+  const propertiesByDocumentId = await listPropertiesForDatabaseDocuments(
+    databaseId,
+    documents,
+  );
   const queuedBodyHydrationItemIds =
     items.length > 0
       ? new Set(
@@ -234,7 +239,7 @@ export async function getContentDatabaseResponse(
       bodyHydration: serializeBodyHydration(item, {
         queued: bodyHydrationQueued,
       }),
-      properties: await listPropertiesForDatabase(databaseId, document),
+      properties: propertiesByDocumentId.get(document.id) ?? [],
     });
   }
 

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

@@ -41,6 +41,7 @@ import {
   type DocumentPropertyType,
   type DocumentPropertyValue,
 } from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
 
 type DocumentRow = InferSelectModel<typeof schema.documents>;
 type ContentDatabaseRow = InferSelectModel<typeof schema.contentDatabases>;
@@ -526,6 +527,173 @@ export async function listPropertiesForDatabase(
   return nextProperties;
 }
 
+function serializePropertyDefinition(
+  definition: typeof schema.documentPropertyDefinitions.$inferSelect,
+) {
+  const type = definition.type as DocumentPropertyType;
+  return {
+    id: definition.id,
+    databaseId: definition.databaseId,
+    name: definition.name,
+    type,
+    visibility: normalizePropertyVisibility(definition.visibility),
+    options: parsePropertyOptions(definition.optionsJson),
+    position: definition.position,
+    createdAt: definition.createdAt,
+    updatedAt: definition.updatedAt,
+  };
+}
+
+function propertyValueKey(documentId: string, propertyId: string) {
+  return `${documentId}\0${propertyId}`;
+}
+
+export async function listPropertiesForDatabaseDocuments(
+  databaseId: string,
+  valueDocuments: DocumentRow[],
+): Promise<Map<string, DocumentProperty[]>> {
+  const db = getDb();
+  const definitions = await db
+    .select()
+    .from(schema.documentPropertyDefinitions)
+    .where(eq(schema.documentPropertyDefinitions.databaseId, databaseId))
+    .orderBy(asc(schema.documentPropertyDefinitions.position));
+  const result = new Map<string, DocumentProperty[]>();
+  if (valueDocuments.length === 0) return result;
+  if (definitions.length === 0) {
+    for (const document of valueDocuments) result.set(document.id, []);
+    return result;
+  }
+
+  const documentIds = valueDocuments.map((document) => document.id);
+  const propertyIds = definitions.map((definition) => definition.id);
+  const values: Array<typeof schema.documentPropertyValues.$inferSelect> = [];
+  for (const documentIdChunk of chunks(documentIds, 200)) {
+    for (const propertyIdChunk of chunks(propertyIds, 200)) {
+      values.push(
+        ...(await db
+          .select()
+          .from(schema.documentPropertyValues)
+          .where(
+            and(
+              inArray(
+                schema.documentPropertyValues.documentId,
+                documentIdChunk,
+              ),
+              inArray(
+                schema.documentPropertyValues.propertyId,
+                propertyIdChunk,
+              ),
+            ),
+          )),
+      );
+    }
+  }
+  const valueByDocumentAndProperty = new Map(
+    values.map((value) => [
+      propertyValueKey(value.documentId, value.propertyId),
+      value,
+    ]),
+  );
+
+  const rowNumberByDocumentId = definitions.some((definition) =>
+    isComputedPropertyType(definition.type as DocumentPropertyType),
+  )
+    ? await databaseRowNumbersByDocumentId(databaseId)
+    : new Map<string, number>();
+
+  const blockContentByDocumentAndProperty = new Map<string, string>();
+  const hasAdditionalBlocksFields = definitions.some((definition) => {
+    const type = definition.type as DocumentPropertyType;
+    return (
+      isBlocksPropertyType(type) &&
+      !isPrimaryBlocksField(parsePropertyOptions(definition.optionsJson))
+    );
+  });
+  if (hasAdditionalBlocksFields) {
+    for (const documentIdChunk of chunks(documentIds, 200)) {
+      const rows = await db
+        .select({
+          documentId: schema.documentBlockFieldContents.documentId,
+          propertyId: schema.documentBlockFieldContents.propertyId,
+          content: schema.documentBlockFieldContents.content,
+        })
+        .from(schema.documentBlockFieldContents)
+        .where(
+          inArray(
+            schema.documentBlockFieldContents.documentId,
+            documentIdChunk,
+          ),
+        );
+      for (const row of rows) {
+        blockContentByDocumentAndProperty.set(
+          propertyValueKey(row.documentId, row.propertyId),
+          row.content ?? "",
+        );
+      }
+    }
+  }
+
+  for (const document of valueDocuments) {
+    const properties = definitions.map((definition) => {
+      const propertyDefinition = serializePropertyDefinition(definition);
+      const storedValue = valueByDocumentAndProperty.get(
+        propertyValueKey(document.id, definition.id),
+      );
+      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),
+        editable: !isComputedPropertyType(propertyDefinition.type),
+      };
+    });
+
+    const valuesByName = Object.fromEntries(
+      properties
+        .filter((property) => property.definition.type !== "formula")
+        .map((property) => [property.definition.name, property.value]),
+    );
+    const evaluatedProperties = properties.map((property) =>
+      property.definition.type === "formula"
+        ? {
+            ...property,
+            value: evaluatePropertyFormula(
+              property.definition.options.formula,
+              valuesByName,
+            ),
+          }
+        : property,
+    );
+    const nextProperties = [];
+    for (const property of evaluatedProperties) {
+      if (property.definition.type === "rollup") {
+        nextProperties.push({
+          ...property,
+          value: await evaluatePropertyRollup(property, evaluatedProperties),
+        });
+      } else {
+        nextProperties.push(property);
+      }
+    }
+    result.set(document.id, nextProperties);
+  }
+
+  return result;
+}
+
 async function evaluatePropertyRollup(
   property: DocumentProperty,
   properties: DocumentProperty[],

package/corpus/templates/content/actions/add-content-database-source-field-property.ts

@@ -21,6 +21,7 @@ import {
   type DocumentPropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
 import {
   resolveDatabaseForSourceMutation,
   serializeSourceField,
@@ -343,7 +344,11 @@ export default defineAction({
     const sourceRows = isSecondary
       ? []
       : await db
-          .select()
+          .select({
+            databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
+            documentId: schema.contentDatabaseSourceRows.documentId,
+            sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
+          })
           .from(schema.contentDatabaseSourceRows)
           .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
     const builderMetadata = builderMetadataForSourceField({
@@ -397,17 +402,19 @@ export default defineAction({
       options,
     );
     if (itemValues.length > 0) {
-      await db.insert(schema.documentPropertyValues).values(
-        itemValues.map((row) => ({
-          id: nanoid(),
-          ownerEmail: database.ownerEmail,
-          documentId: row.documentId,
-          propertyId,
-          valueJson: serializePropertyValue(row.value),
-          createdAt: now,
-          updatedAt: now,
-        })),
-      );
+      for (const chunk of chunks(itemValues, 200)) {
+        await db.insert(schema.documentPropertyValues).values(
+          chunk.map((row) => ({
+            id: nanoid(),
+            ownerEmail: database.ownerEmail,
+            documentId: row.documentId,
+            propertyId,
+            valueJson: serializePropertyValue(row.value),
+            createdAt: now,
+            updatedAt: now,
+          })),
+        );
+      }
     }
 
     const sourceField = serializeSourceField(

package/corpus/templates/content/actions/bind-content-database-source-field.ts

@@ -9,6 +9,7 @@ import type {
   ContentDatabaseResponse,
 } from "../shared/api.js";
 import { serializePropertyValue } from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
 import { resolveDatabaseForSourceMutation } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import { nanoid } from "./_property-utils.js";
@@ -207,7 +208,11 @@ export default defineAction({
     }
     if (federationRole !== "secondary") {
       const sourceRows = await db
-        .select()
+        .select({
+          databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
+          documentId: schema.contentDatabaseSourceRows.documentId,
+          sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
+        })
         .from(schema.contentDatabaseSourceRows)
         .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
       const itemValues = sourceFieldPropertyValuesFromRows(
@@ -237,17 +242,19 @@ export default defineAction({
           );
       }
       if (itemValues.length > 0) {
-        await db.insert(schema.documentPropertyValues).values(
-          itemValues.map((row) => ({
-            id: nanoid(),
-            ownerEmail: database.ownerEmail,
-            documentId: row.documentId,
-            propertyId: property.id,
-            valueJson: serializePropertyValue(row.value),
-            createdAt: now,
-            updatedAt: now,
-          })),
-        );
+        for (const chunk of chunks(itemValues, 200)) {
+          await db.insert(schema.documentPropertyValues).values(
+            chunk.map((row) => ({
+              id: nanoid(),
+              ownerEmail: database.ownerEmail,
+              documentId: row.documentId,
+              propertyId: property.id,
+              valueJson: serializePropertyValue(row.value),
+              createdAt: now,
+              updatedAt: now,
+            })),
+          );
+        }
       }
     }
 

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

@@ -5,6 +5,7 @@ import { and, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { chunks } from "./_batch-utils.js";
 import {
   deleteLocalFileDocument,
   isLocalDocumentId,
@@ -13,21 +14,13 @@ import {
 
 const DELETE_BATCH_SIZE = 90;
 
-function chunks<T>(items: T[], size = DELETE_BATCH_SIZE): T[][] {
-  const out: T[][] = [];
-  for (let index = 0; index < items.length; index += size) {
-    out.push(items.slice(index, index + size));
-  }
-  return out;
-}
-
 async function selectDocumentChildren(
   db: ReturnType<typeof getDb>,
   parentIds: string[],
   ownerEmail: string,
 ) {
   const rows: Array<{ id: string }> = [];
-  for (const batch of chunks(parentIds)) {
+  for (const batch of chunks(parentIds, DELETE_BATCH_SIZE)) {
     rows.push(
       ...(await db
         .select({ id: schema.documents.id })
@@ -49,7 +42,7 @@ async function selectOwnedDatabaseIds(
   ownerEmail: string,
 ) {
   const rows: Array<{ id: string }> = [];
-  for (const batch of chunks(documentIds)) {
+  for (const batch of chunks(documentIds, DELETE_BATCH_SIZE)) {
     rows.push(
       ...(await db
         .select({ id: schema.contentDatabases.id })
@@ -71,7 +64,7 @@ async function selectDatabaseItemDocuments(
   ownerEmail: string,
 ) {
   const rows: Array<{ documentId: string }> = [];
-  for (const batch of chunks(databaseIds)) {
+  for (const batch of chunks(databaseIds, DELETE_BATCH_SIZE)) {
     rows.push(
       ...(await db
         .select({ documentId: schema.contentDatabaseItems.documentId })
@@ -87,7 +80,10 @@ async function selectDatabaseItemDocuments(
   if (rows.length === 0) return rows;
 
   const ownedRows: Array<{ id: string }> = [];
-  for (const batch of chunks(rows.map((row) => row.documentId))) {
+  for (const batch of chunks(
+    rows.map((row) => row.documentId),
+    DELETE_BATCH_SIZE,
+  )) {
     ownedRows.push(
       ...(await db
         .select({ id: schema.documents.id })
@@ -167,7 +163,7 @@ async function deleteWhereIn<T>(
   items: T[],
   run: (batch: T[]) => Promise<unknown>,
 ) {
-  for (const batch of chunks(items)) {
+  for (const batch of chunks(items, DELETE_BATCH_SIZE)) {
     if (batch.length > 0) await run(batch);
   }
 }

package/corpus/templates/content/actions/get-content-database-personal-view.ts

@@ -0,0 +1,27 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import {
+  assertContentDatabaseViewerAccess,
+  readPersonalDatabaseViewOverrides,
+} from "./_content-database-personal-view.js";
+
+export default defineAction({
+  description:
+    "Get the current user's personal saved filter, sort, and active view overrides for a content database.",
+  schema: z.object({
+    databaseId: z.string().describe("Database ID"),
+  }),
+  http: { method: "GET" },
+  run: async ({ databaseId }, ctx) => {
+    if (!ctx?.userEmail) throw new Error("Not authenticated.");
+    await assertContentDatabaseViewerAccess(databaseId);
+    return {
+      databaseId,
+      overrides: await readPersonalDatabaseViewOverrides(
+        ctx.userEmail,
+        databaseId,
+      ),
+    };
+  },
+});

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

@@ -4,7 +4,8 @@ import { z } from "zod";
 
 import type { ContentDatabaseSourceStatusResponse } from "../shared/api.js";
 import {
-  getContentDatabaseSourceSnapshotForWrite,
+  getContentDatabaseSourceSnapshot,
+  getContentDatabaseSourceSnapshotById,
   getExistingSourceForWrite,
   resyncBuilderCmsSourceSnapshot,
   resyncMockSourceSnapshot,
@@ -60,10 +61,9 @@ export default defineAction({
     } else {
       throw new Error(`Unsupported source type "${source.sourceType}".`);
     }
-    const snapshot = await getContentDatabaseSourceSnapshotForWrite(
-      database,
-      args.sourceId,
-    );
+    const snapshot = args.sourceId
+      ? await getContentDatabaseSourceSnapshotById(database, args.sourceId)
+      : await getContentDatabaseSourceSnapshot(database);
 
     const builderProgress =
       snapshot?.sourceType === "builder-cms" ? snapshot.metadata : null;

package/corpus/templates/content/actions/update-content-database-personal-view.ts

@@ -0,0 +1,31 @@
+import { defineAction } from "@agent-native/core";
+import { deleteUserSetting, putUserSetting } from "@agent-native/core/settings";
+import { z } from "zod";
+
+import {
+  assertContentDatabaseViewerAccess,
+  personalDatabaseViewSettingKey,
+  personalViewOverridesSchema,
+} from "./_content-database-personal-view.js";
+
+export default defineAction({
+  description:
+    "Update or clear the current user's personal saved filter, sort, and active view overrides for a content database.",
+  schema: z.object({
+    databaseId: z.string().describe("Database ID"),
+    overrides: personalViewOverridesSchema.nullable(),
+  }),
+  run: async ({ databaseId, overrides }, ctx) => {
+    if (!ctx?.userEmail) throw new Error("Not authenticated.");
+    await assertContentDatabaseViewerAccess(databaseId);
+
+    const key = personalDatabaseViewSettingKey(databaseId);
+    if (overrides) {
+      await putUserSetting(ctx.userEmail, key, overrides);
+    } else {
+      await deleteUserSetting(ctx.userEmail, key);
+    }
+
+    return { databaseId, overrides };
+  },
+});

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

@@ -25,12 +25,15 @@ const filterSchema = z.object({
     "less_than",
     "before",
     "after",
+    "between",
     "is_checked",
     "is_unchecked",
     "is_empty",
     "is_not_empty",
   ]),
   value: z.string(),
+  filterGroupId: z.string().optional(),
+  parentFilterGroupId: z.string().optional(),
 });
 
 const columnCalculationSchema = z.enum([

package/corpus/templates/content/app/components/editor/DocumentProperties.tsx

@@ -440,7 +440,7 @@ function personInitials(value: string) {
   );
 }
 
-function PersonPill({ value }: { value: string }) {
+export function PersonPill({ value }: { value: string }) {
   return (
     <span className="inline-flex max-w-full items-center gap-1.5 rounded bg-muted px-1.5 py-0.5 text-xs font-medium text-foreground">
       <span className="flex size-4 shrink-0 items-center justify-center rounded-full bg-background text-[9px] font-semibold text-muted-foreground">

package/corpus/templates/content/app/components/editor/body-hydration.ts

@@ -39,29 +39,39 @@ export function builderBodyHydrationDisplayHydratedCount(args: {
 export function databaseItemBodyHydrationIsPending(
   item: Pick<ContentDatabaseItem, "bodyHydration" | "document">,
 ) {
+  const hydration =
+    item.bodyHydration ?? item.document.databaseMembership?.bodyHydration;
   if (
-    item.document.databaseMembership?.sourceId &&
-    !item.bodyHydration &&
-    !item.document.databaseMembership.bodyHydration
+    sourceBackedEmptyBodyNeedsHydration({
+      sourceId: item.document.databaseMembership?.sourceId,
+      content: item.document.content,
+      hydration,
+    })
   ) {
     return true;
   }
-  return builderBodyHydrationIsPending(
-    item.bodyHydration ?? item.document.databaseMembership?.bodyHydration,
-  );
+  return builderBodyHydrationIsPending(hydration);
 }
 
 export function documentBodyHydrationIsPending(
-  document: Pick<Document, "databaseMembership">,
+  document: Pick<Document, "content" | "databaseMembership">,
 ) {
-  return builderBodyHydrationIsPending(
-    document.databaseMembership?.bodyHydration,
-  );
+  const hydration = document.databaseMembership?.bodyHydration;
+  if (
+    sourceBackedEmptyBodyNeedsHydration({
+      sourceId: document.databaseMembership?.sourceId,
+      content: document.content,
+      hydration,
+    })
+  ) {
+    return true;
+  }
+  return builderBodyHydrationIsPending(hydration);
 }
 
 export function previewBodyHydrationIsPending(args: {
   item: Pick<ContentDatabaseItem, "bodyHydration" | "document">;
-  document: Pick<Document, "databaseMembership"> | null | undefined;
+  document: Pick<Document, "content" | "databaseMembership"> | null | undefined;
 }) {
   const membership =
     args.document?.databaseMembership ?? args.item.document.databaseMembership;
@@ -101,6 +111,20 @@ export function isEffectivelyEmptyDocumentContent(
   return normalized === "" || normalized === "<empty-block/>";
 }
 
+function sourceBackedEmptyBodyNeedsHydration(args: {
+  sourceId: string | null | undefined;
+  content: string | null | undefined;
+  hydration: ContentDatabaseBodyHydration | null | undefined;
+}) {
+  if (!args.sourceId || !isEffectivelyEmptyDocumentContent(args.content)) {
+    return false;
+  }
+  if (!args.hydration) return true;
+  if (builderBodyHydrationIsPending(args.hydration)) return true;
+  if (args.hydration.status === "error") return false;
+  return args.hydration.status === "hydrated" && !args.hydration.version;
+}
+
 export function shouldIgnorePreviewEmptyNormalization(args: {
   currentContent: string | null | undefined;
   nextContent: string | null | undefined;