@agent-native/core 0.90.1 → 0.90.3

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

@@ -1,78 +1,363 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { deleteDatabaseDataForDocument } from "./_database-utils.js";
 import {
   deleteLocalFileDocument,
   isLocalDocumentId,
   isContentLocalFileMode,
 } from "./_local-file-documents.js";
 
-export async function deleteDocumentRecursive(
+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>,
-  id: string,
+  parentIds: string[],
   ownerEmail: string,
-): Promise<string[]> {
-  const children = await db
-    .select({ id: schema.documents.id })
-    .from(schema.documents)
-    .where(
-      and(
-        eq(schema.documents.parentId, id),
-        eq(schema.documents.ownerEmail, ownerEmail),
-      ),
+) {
+  const rows: Array<{ id: string }> = [];
+  for (const batch of chunks(parentIds)) {
+    rows.push(
+      ...(await db
+        .select({ id: schema.documents.id })
+        .from(schema.documents)
+        .where(
+          and(
+            inArray(schema.documents.parentId, batch),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        )),
     );
+  }
+  return rows;
+}
 
-  const deleted: string[] = [];
-  for (const child of children) {
-    deleted.push(...(await deleteDocumentRecursive(db, child.id, ownerEmail)));
+async function selectOwnedDatabaseIds(
+  db: ReturnType<typeof getDb>,
+  documentIds: string[],
+  ownerEmail: string,
+) {
+  const rows: Array<{ id: string }> = [];
+  for (const batch of chunks(documentIds)) {
+    rows.push(
+      ...(await db
+        .select({ id: schema.contentDatabases.id })
+        .from(schema.contentDatabases)
+        .where(
+          and(
+            inArray(schema.contentDatabases.documentId, batch),
+            eq(schema.contentDatabases.ownerEmail, ownerEmail),
+          ),
+        )),
+    );
   }
+  return rows;
+}
 
-  // Delete database membership/schema, sync links, versions, shares, then document.
-  await deleteDatabaseDataForDocument(id, ownerEmail, db);
-  await db
-    .delete(schema.documentSyncLinks)
-    .where(
-      and(
-        eq(schema.documentSyncLinks.documentId, id),
-        eq(schema.documentSyncLinks.ownerEmail, ownerEmail),
-      ),
+async function selectDatabaseItemDocuments(
+  db: ReturnType<typeof getDb>,
+  databaseIds: string[],
+  ownerEmail: string,
+) {
+  const rows: Array<{ documentId: string }> = [];
+  for (const batch of chunks(databaseIds)) {
+    rows.push(
+      ...(await db
+        .select({ documentId: schema.contentDatabaseItems.documentId })
+        .from(schema.contentDatabaseItems)
+        .where(
+          and(
+            inArray(schema.contentDatabaseItems.databaseId, batch),
+            eq(schema.contentDatabaseItems.ownerEmail, ownerEmail),
+          ),
+        )),
     );
-  await db
-    .delete(schema.documentVersions)
-    .where(
-      and(
-        eq(schema.documentVersions.documentId, id),
-        eq(schema.documentVersions.ownerEmail, ownerEmail),
-      ),
+  }
+  if (rows.length === 0) return rows;
+
+  const ownedRows: Array<{ id: string }> = [];
+  for (const batch of chunks(rows.map((row) => row.documentId))) {
+    ownedRows.push(
+      ...(await db
+        .select({ id: schema.documents.id })
+        .from(schema.documents)
+        .where(
+          and(
+            inArray(schema.documents.id, batch),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        )),
     );
-  await db
-    .delete(schema.builderDocSidecars)
-    .where(
-      and(
-        eq(schema.builderDocSidecars.documentId, id),
-        eq(schema.builderDocSidecars.ownerEmail, ownerEmail),
-      ),
+  }
+
+  return ownedRows.map((row) => ({ documentId: row.id }));
+}
+
+async function collectDocumentSubtreeForDelete(
+  db: ReturnType<typeof getDb>,
+  rootId: string,
+  ownerEmail: string,
+) {
+  const documentIds = new Set([rootId]);
+  const ownedDatabaseIds = new Set<string>();
+  let frontier = [rootId];
+
+  while (frontier.length > 0) {
+    const next = new Set<string>();
+
+    for (const child of await selectDocumentChildren(
+      db,
+      frontier,
+      ownerEmail,
+    )) {
+      if (!documentIds.has(child.id)) {
+        documentIds.add(child.id);
+        next.add(child.id);
+      }
+    }
+
+    const ownedDatabases = await selectOwnedDatabaseIds(
+      db,
+      frontier,
+      ownerEmail,
+    );
+    const newDatabaseIds = ownedDatabases
+      .map((database) => database.id)
+      .filter((databaseId) => {
+        if (ownedDatabaseIds.has(databaseId)) return false;
+        ownedDatabaseIds.add(databaseId);
+        return true;
+      });
+
+    if (newDatabaseIds.length > 0) {
+      const itemDocuments = await selectDatabaseItemDocuments(
+        db,
+        newDatabaseIds,
+        ownerEmail,
+      );
+      for (const item of itemDocuments) {
+        if (!documentIds.has(item.documentId)) {
+          documentIds.add(item.documentId);
+          next.add(item.documentId);
+        }
+      }
+    }
+
+    frontier = [...next];
+  }
+
+  return {
+    documentIds: [...documentIds],
+    ownedDatabaseIds: [...ownedDatabaseIds],
+  };
+}
+
+async function deleteWhereIn<T>(
+  items: T[],
+  run: (batch: T[]) => Promise<unknown>,
+) {
+  for (const batch of chunks(items)) {
+    if (batch.length > 0) await run(batch);
+  }
+}
+
+export async function deleteDocumentRecursive(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  ownerEmail: string,
+): Promise<string[]> {
+  const { documentIds, ownedDatabaseIds } =
+    await collectDocumentSubtreeForDelete(db, id, ownerEmail);
+
+  const propertyDefinitionIds: string[] = [];
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    propertyDefinitionIds.push(
+      ...(
+        await db
+          .select({ id: schema.documentPropertyDefinitions.id })
+          .from(schema.documentPropertyDefinitions)
+          .where(
+            inArray(
+              schema.documentPropertyDefinitions.databaseId,
+              databaseIdBatch,
+            ),
+          )
+      ).map((definition) => definition.id),
     );
-  await db
-    .delete(schema.documentComments)
-    .where(
-      and(
-        eq(schema.documentComments.documentId, id),
-        eq(schema.documentComments.ownerEmail, ownerEmail),
-      ),
+  });
+
+  const sourceIds: string[] = [];
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    sourceIds.push(
+      ...(
+        await db
+          .select({ id: schema.contentDatabaseSources.id })
+          .from(schema.contentDatabaseSources)
+          .where(
+            inArray(schema.contentDatabaseSources.databaseId, databaseIdBatch),
+          )
+      ).map((source) => source.id),
     );
-  await db
-    .delete(schema.documentShares)
-    .where(eq(schema.documentShares.resourceId, id));
-  await db.delete(schema.documents).where(eq(schema.documents.id, id));
-  deleted.push(id);
+  });
+
+  // Delete database membership/schema, sync links, versions, shares, then documents.
+  await deleteWhereIn(sourceIds, async (sourceIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseBodyHydrationQueue)
+      .where(
+        inArray(
+          schema.contentDatabaseBodyHydrationQueue.sourceId,
+          sourceIdBatch,
+        ),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceExecutions)
+      .where(
+        inArray(schema.contentDatabaseSourceExecutions.sourceId, sourceIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceChangeReviews)
+      .where(
+        inArray(
+          schema.contentDatabaseSourceChangeReviews.sourceId,
+          sourceIdBatch,
+        ),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceChangeSets)
+      .where(
+        inArray(schema.contentDatabaseSourceChangeSets.sourceId, sourceIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceRows)
+      .where(inArray(schema.contentDatabaseSourceRows.sourceId, sourceIdBatch));
+    await db
+      .delete(schema.contentDatabaseSourceFields)
+      .where(
+        inArray(schema.contentDatabaseSourceFields.sourceId, sourceIdBatch),
+      );
+  });
+
+  await deleteWhereIn(propertyDefinitionIds, async (propertyIdBatch) => {
+    await db
+      .delete(schema.documentPropertyValues)
+      .where(
+        inArray(schema.documentPropertyValues.propertyId, propertyIdBatch),
+      );
+    await db
+      .delete(schema.documentBlockFieldContents)
+      .where(
+        inArray(schema.documentBlockFieldContents.propertyId, propertyIdBatch),
+      );
+  });
+
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseBodyHydrationQueue)
+      .where(
+        inArray(
+          schema.contentDatabaseBodyHydrationQueue.documentId,
+          documentIdBatch,
+        ),
+      );
+    await db
+      .delete(schema.documentPropertyValues)
+      .where(
+        and(
+          inArray(schema.documentPropertyValues.documentId, documentIdBatch),
+          eq(schema.documentPropertyValues.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentBlockFieldContents)
+      .where(
+        inArray(schema.documentBlockFieldContents.documentId, documentIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabaseItems)
+      .where(inArray(schema.contentDatabaseItems.documentId, documentIdBatch));
+  });
+
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseItems)
+      .where(inArray(schema.contentDatabaseItems.databaseId, databaseIdBatch));
+    await db
+      .delete(schema.contentDatabaseSources)
+      .where(
+        inArray(schema.contentDatabaseSources.databaseId, databaseIdBatch),
+      );
+    await db
+      .delete(schema.documentPropertyDefinitions)
+      .where(
+        inArray(schema.documentPropertyDefinitions.databaseId, databaseIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabases)
+      .where(inArray(schema.contentDatabases.id, databaseIdBatch));
+  });
+
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.documentSyncLinks)
+      .where(
+        and(
+          inArray(schema.documentSyncLinks.documentId, documentIdBatch),
+          eq(schema.documentSyncLinks.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentVersions)
+      .where(
+        and(
+          inArray(schema.documentVersions.documentId, documentIdBatch),
+          eq(schema.documentVersions.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.builderDocSidecars)
+      .where(
+        and(
+          inArray(schema.builderDocSidecars.documentId, documentIdBatch),
+          eq(schema.builderDocSidecars.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentComments)
+      .where(
+        and(
+          inArray(schema.documentComments.documentId, documentIdBatch),
+          eq(schema.documentComments.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentShares)
+      .where(inArray(schema.documentShares.resourceId, documentIdBatch));
+  });
+
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.documents)
+      .where(
+        and(
+          inArray(schema.documents.id, documentIdBatch),
+          eq(schema.documents.ownerEmail, ownerEmail),
+        ),
+      );
+  });
 
-  return deleted;
+  return documentIds;
 }
 
 export default defineAction({

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

@@ -49,9 +49,18 @@ export default defineAction({
     }
 
     const access = await resolveAccess("document", args.id);
-    if (!access) throw new Error(`Document "${args.id}" not found`);
+    // Not-found is a deterministic client-state condition (deleted or
+    // inaccessible document still referenced by an open tab) — 404, not a
+    // 500 that floods the console as Internal Server Error.
+    if (!access) {
+      throw Object.assign(new Error(`Document "${args.id}" not found`), {
+        statusCode: 404,
+      });
+    }
     if (await isSoftDeletedDatabaseDocument(args.id)) {
-      throw new Error(`Document "${args.id}" not found`);
+      throw Object.assign(new Error(`Document "${args.id}" not found`), {
+        statusCode: 404,
+      });
     }
     const doc = access.resource;
     const database = await getDatabaseByDocumentId(doc.id);

package/corpus/templates/content/actions/list-content-databases.ts

@@ -19,6 +19,10 @@ export default defineAction({
       .string()
       .optional()
       .describe("Database id to omit from the results."),
+    excludeDatabaseIds: z
+      .array(z.string())
+      .optional()
+      .describe("Database ids to omit from the results."),
     query: z.string().optional().describe("Optional title search text."),
     limit: z.coerce
       .number()
@@ -34,6 +38,12 @@ export default defineAction({
     const db = getDb();
     const query = args.query?.trim();
     const pattern = query ? `%${escapeLike(query.toLowerCase())}%` : null;
+    const excludedDatabaseIds = new Set(
+      [
+        args.excludeDatabaseId?.trim(),
+        ...(args.excludeDatabaseIds ?? []).map((id) => id.trim()),
+      ].filter((id): id is string => !!id),
+    );
     // The same access + discovery filter the sidebar uses, so the picker shows
     // owned AND shared/org databases and never a trashed/hidden one.
     const queryBuilder = db
@@ -52,8 +62,11 @@ export default defineAction({
           accessFilter(schema.documents, schema.documentShares),
           documentDiscoveryFilter(),
           isNull(schema.contentDatabases.deletedAt),
-          args.excludeDatabaseId
-            ? ne(schema.contentDatabases.id, args.excludeDatabaseId)
+          excludedDatabaseIds.size === 1
+            ? ne(
+                schema.contentDatabases.id,
+                Array.from(excludedDatabaseIds)[0]!,
+              )
             : undefined,
           pattern
             ? sql`lower(${schema.documents.title}) LIKE ${pattern} ESCAPE '\\'`
@@ -66,13 +79,48 @@ export default defineAction({
       ? await queryBuilder.limit(args.limit)
       : await queryBuilder;
 
-    const databases = rows.map((row) => ({
-      databaseId: row.id,
-      documentId: row.documentId,
-      // The document's live title (matches the sidebar) rather than the
-      // possibly-stale content_databases.title.
-      title: row.title ?? "Untitled database",
-    }));
+    const localTableSources =
+      excludedDatabaseIds.size > 0
+        ? await db
+            .select({
+              databaseId: schema.contentDatabaseSources.databaseId,
+              sourceTable: schema.contentDatabaseSources.sourceTable,
+            })
+            .from(schema.contentDatabaseSources)
+            .where(eq(schema.contentDatabaseSources.sourceType, "local-table"))
+        : [];
+    const localTableTargetByDatabaseId = new Map(
+      localTableSources.map((source) => [
+        source.databaseId,
+        source.sourceTable,
+      ]),
+    );
+    const sourceChainIncludesExcludedDatabase = (databaseId: string) => {
+      const seen = new Set<string>();
+      let current: string | undefined = databaseId;
+      while (current && !seen.has(current)) {
+        if (excludedDatabaseIds.has(current)) return true;
+        seen.add(current);
+        current = localTableTargetByDatabaseId.get(current);
+      }
+      return false;
+    };
+
+    const databases = rows
+      // Exclusion ids may be database ids OR database document ids — the
+      // settings panel only has the document id before any source exists.
+      .filter(
+        (row) =>
+          !excludedDatabaseIds.has(row.documentId) &&
+          !sourceChainIncludesExcludedDatabase(row.id),
+      )
+      .map((row) => ({
+        databaseId: row.id,
+        documentId: row.documentId,
+        // The document's live title (matches the sidebar) rather than the
+        // possibly-stale content_databases.title.
+        title: row.title ?? "Untitled database",
+      }));
 
     return { databases };
   },

package/corpus/templates/content/actions/prepare-builder-source-review.ts

@@ -28,6 +28,8 @@ import {
 } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 
+export const BUILDER_SOURCE_REVIEW_PREPARE_LIMIT = 100;
+
 function riskRank(level: ContentDatabaseSourceRiskLevel) {
   if (level === "high") return 3;
   if (level === "medium") return 2;
@@ -41,6 +43,12 @@ function maxRisk(
   return riskRank(next) > riskRank(current) ? next : current;
 }
 
+function reviewPreparePriority(changeSet: ContentDatabaseSourceChangeSet) {
+  if (changeSet.state === "pending_push") return 0;
+  if (changeSet.state === "staged_revision") return 1;
+  return 2;
+}
+
 function parsePayload(value: string) {
   try {
     const parsed = JSON.parse(value) as unknown;
@@ -146,6 +154,8 @@ export function buildBuilderSourceReviewPayload(args: {
     summary,
     sourceName: args.source.sourceName,
     sourceTable: args.source.sourceTable,
+    totalRowCount: args.changeSets.length,
+    preparedRowLimit: args.changeSets.length,
     pushMode,
     dryRunOnly: !args.source.capabilities.liveWritesEnabled,
     liveWritesEnabled: args.source.capabilities.liveWritesEnabled,
@@ -399,16 +409,19 @@ export default defineAction({
     if (!snapshot || snapshot.sourceType !== "builder-cms") {
       throw new Error("Attach a Builder CMS source before reviewing updates.");
     }
-    const reviewableChanges = snapshot.changeSets.filter(
+    const allReviewableChanges = snapshot.changeSets.filter(
       (changeSet) =>
         changeSet.direction === "outbound" &&
         (changeSet.state === "pending_push" ||
           changeSet.state === "staged_revision" ||
           changeSet.state === "approved"),
     );
-    if (reviewableChanges.length === 0) {
+    if (allReviewableChanges.length === 0) {
       throw new Error("No pending local Builder changes to review.");
     }
+    const reviewableChanges = [...allReviewableChanges]
+      .sort((a, b) => reviewPreparePriority(a) - reviewPreparePriority(b))
+      .slice(0, BUILDER_SOURCE_REVIEW_PREPARE_LIMIT);
 
     const now = new Date().toISOString();
     const reviewerEmail =
@@ -466,12 +479,16 @@ export default defineAction({
     );
     const response = await getContentDatabaseResponse(database.id);
 
+    const review = buildBuilderSourceReviewPayload({
+      source: reviewedSnapshot,
+      changeSets: reviewedChangeSets,
+    });
+    review.totalRowCount = allReviewableChanges.length;
+    review.preparedRowLimit = BUILDER_SOURCE_REVIEW_PREPARE_LIMIT;
+
     return {
       ...response,
-      review: buildBuilderSourceReviewPayload({
-        source: reviewedSnapshot,
-        changeSets: reviewedChangeSets,
-      }),
+      review,
     };
   },
 });

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

@@ -14,7 +14,7 @@ import { serializeDatabase } from "./_property-utils.js";
 
 export default defineAction({
   description:
-    "Refresh the local read-only source status envelope for a content database. Mock-local and Builder CMS fixture sources resync field mappings and row identity without external API calls or provider writes.",
+    "Refresh the local read-only source status envelope for a content database. Mock-local and Builder CMS fixture sources resync field mappings and row identity without provider writes. For Builder CMS sources, set fullRefresh to true when you need to read every available page in one action call instead of continuing one partial page.",
   schema: z.object({
     databaseId: z.string().optional().describe("Database ID"),
     documentId: z.string().optional().describe("Database document/page ID"),
@@ -22,6 +22,12 @@ export default defineAction({
       .string()
       .optional()
       .describe("Target source ID (defaults to the primary source)"),
+    fullRefresh: z
+      .boolean()
+      .optional()
+      .describe(
+        "For Builder CMS sources, read all available pages in this refresh instead of one continuation page.",
+      ),
   }),
   run: async (args): Promise<ContentDatabaseSourceStatusResponse> => {
     const database = await resolveDatabaseForSourceMutation(args);
@@ -42,7 +48,12 @@ export default defineAction({
     if (source.sourceType === "mock-local") {
       await resyncMockSourceSnapshot({ database, source, now });
     } else if (source.sourceType === "builder-cms") {
-      await resyncBuilderCmsSourceSnapshot({ database, source, now });
+      await resyncBuilderCmsSourceSnapshot({
+        database,
+        source,
+        now,
+        runFullRefresh: args.fullRefresh === true,
+      });
     } else if (source.sourceType === "local-table") {
       // Read-only federated secondary; its rows are re-read on demand, nothing
       // to resync against the primary's local snapshot here.
@@ -54,11 +65,23 @@ export default defineAction({
       args.sourceId,
     );
 
+    const builderProgress =
+      snapshot?.sourceType === "builder-cms" ? snapshot.metadata : null;
+    const builderFetching =
+      builderProgress?.sourceFetchState === "fetching" ||
+      snapshot?.syncState === "refreshing";
+    const builderFetched =
+      typeof builderProgress?.lastReadFetchedEntryCount === "number"
+        ? builderProgress.lastReadFetchedEntryCount
+        : undefined;
+
     return {
       database: serializeDatabase(database),
       mode: "source-backed",
       summary: snapshot
-        ? `${snapshot.sourceName} resynced locally; field mappings and row identity now reflect the current database snapshot.`
+        ? builderFetching
+          ? `${snapshot.sourceName} fetched ${builderFetched ?? "some"} rows. Run refresh again to continue loading the remaining Builder rows.`
+          : `${snapshot.sourceName} resynced locally; field mappings and row identity now reflect the current database snapshot.`
         : "Source metadata refreshed.",
       source: snapshot,
     };

package/corpus/templates/content/actions/restore-content-database.ts

@@ -63,6 +63,7 @@ export default defineAction({
     return {
       success: true,
       databaseId,
+      documentId: ownership.database.documentId,
       deletedAt: null,
     };
   },