@agent-native/core 0.114.5 → 0.114.7

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

@@ -1,10 +1,11 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { eq } from "drizzle-orm";
+import { assertAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
-import { getDb, schema } from "../server/db/index.js";
+import { getDb } from "../server/db/index.js";
 import { assertContentDatabaseLifecycleAccess } from "./_content-database-lifecycle.js";
+import { trashDocumentSubtree } from "./delete-document.js";
 
 export default defineAction({
   description:
@@ -17,15 +18,17 @@ export default defineAction({
     if (database.systemRole) {
       throw new Error("System Content databases cannot be deleted");
     }
+    await assertAccess("document", database.documentId, "admin");
     const db = getDb();
     const deletedAt = database.deletedAt ?? new Date().toISOString();
-
-    if (!database.deletedAt) {
-      await db
-        .update(schema.contentDatabases)
-        .set({ deletedAt, updatedAt: deletedAt })
-        .where(eq(schema.contentDatabases.id, databaseId));
-    }
+    await db.transaction((tx) =>
+      trashDocumentSubtree(
+        tx as unknown as ReturnType<typeof getDb>,
+        database.documentId,
+        database.ownerEmail,
+        deletedAt,
+      ),
+    );
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 

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

@@ -11,7 +11,7 @@ import {
   resolveDatabaseRowsForBatch,
 } from "./_database-row-batch.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
-import { deleteDocumentRecursive } from "./delete-document.js";
+import { trashDocumentSubtree } from "./delete-document.js";
 
 export default defineAction({
   description:
@@ -57,10 +57,11 @@ export default defineAction({
 
     await db.transaction(async (tx) => {
       for (const row of rows) {
-        await deleteDocumentRecursive(
+        await trashDocumentSubtree(
           tx as unknown as ReturnType<typeof getDb>,
           row.document.id,
           row.document.ownerEmail,
+          now,
         );
       }
       await renumberDatabaseRows(

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

@@ -1,12 +1,13 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, inArray } from "drizzle-orm";
+import { and, eq, inArray, isNotNull, isNull, ne, or } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { chunks } from "./_batch-utils.js";
 import { assertNotWorkspaceCatalogDocuments } from "./_content-space-catalog-guards.js";
+import { renumberDatabaseRows } from "./_database-row-batch.js";
 
 const DELETE_BATCH_SIZE = 90;
 
@@ -155,6 +156,152 @@ async function collectDocumentSubtreeForDelete(
   };
 }
 
+export async function trashDocumentSubtree(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  ownerEmail: string,
+  trashedAt = new Date().toISOString(),
+): Promise<string[]> {
+  const { documentIds } = await collectDocumentSubtreeForDelete(
+    db,
+    id,
+    ownerEmail,
+  );
+  await assertNotWorkspaceCatalogDocuments(db, documentIds, "deleted");
+
+  const independentlyTrashedDatabaseDocumentIds = new Set<string>();
+  for (const batch of chunks(documentIds, DELETE_BATCH_SIZE)) {
+    for (const database of await db
+      .select({ documentId: schema.contentDatabases.documentId })
+      .from(schema.contentDatabases)
+      .where(
+        and(
+          inArray(schema.contentDatabases.documentId, batch),
+          eq(schema.contentDatabases.ownerEmail, ownerEmail),
+          isNotNull(schema.contentDatabases.deletedAt),
+        ),
+      )) {
+      independentlyTrashedDatabaseDocumentIds.add(database.documentId);
+    }
+  }
+
+  const activeDocumentIds: string[] = [];
+  for (const batch of chunks(documentIds, DELETE_BATCH_SIZE)) {
+    activeDocumentIds.push(
+      ...(
+        await db
+          .select({ id: schema.documents.id })
+          .from(schema.documents)
+          .where(
+            and(
+              inArray(schema.documents.id, batch),
+              eq(schema.documents.ownerEmail, ownerEmail),
+              isNull(schema.documents.trashedAt),
+            ),
+          )
+      )
+        .map((document) => document.id)
+        .filter(
+          (documentId) =>
+            !independentlyTrashedDatabaseDocumentIds.has(documentId),
+        ),
+    );
+  }
+
+  for (const batch of chunks(activeDocumentIds, DELETE_BATCH_SIZE)) {
+    await db
+      .update(schema.documents)
+      .set({ trashedAt, trashRootId: id, updatedAt: trashedAt })
+      .where(
+        and(
+          inArray(schema.documents.id, batch),
+          eq(schema.documents.ownerEmail, ownerEmail),
+          isNull(schema.documents.trashedAt),
+        ),
+      );
+    await db
+      .update(schema.contentDatabases)
+      .set({ deletedAt: trashedAt, updatedAt: trashedAt })
+      .where(
+        and(
+          inArray(schema.contentDatabases.documentId, batch),
+          eq(schema.contentDatabases.ownerEmail, ownerEmail),
+          isNull(schema.contentDatabases.deletedAt),
+        ),
+      );
+  }
+
+  return activeDocumentIds;
+}
+
+export async function restoreDocumentSubtree(
+  db: ReturnType<typeof getDb>,
+  rootId: string,
+  ownerEmail: string,
+): Promise<string[]> {
+  const documentIds = (
+    await db
+      .select({ id: schema.documents.id })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.trashRootId, rootId),
+          eq(schema.documents.ownerEmail, ownerEmail),
+        ),
+      )
+  ).map((document) => document.id);
+  if (documentIds.length === 0) return [];
+
+  const now = new Date().toISOString();
+  for (const batch of chunks(documentIds, DELETE_BATCH_SIZE)) {
+    await db
+      .update(schema.documents)
+      .set({ trashedAt: null, trashRootId: null, updatedAt: now })
+      .where(
+        and(
+          inArray(schema.documents.id, batch),
+          eq(schema.documents.ownerEmail, ownerEmail),
+          eq(schema.documents.trashRootId, rootId),
+        ),
+      );
+    await db
+      .update(schema.contentDatabases)
+      .set({ deletedAt: null, updatedAt: now })
+      .where(
+        and(
+          inArray(schema.contentDatabases.documentId, batch),
+          eq(schema.contentDatabases.ownerEmail, ownerEmail),
+        ),
+      );
+  }
+
+  const databaseIds = [
+    ...new Set(
+      (
+        await db
+          .select({ databaseId: schema.contentDatabaseItems.databaseId })
+          .from(schema.contentDatabaseItems)
+          .where(inArray(schema.contentDatabaseItems.documentId, documentIds))
+      ).map((item) => item.databaseId),
+    ),
+  ];
+  for (const databaseId of databaseIds) {
+    const [database] = await db
+      .select()
+      .from(schema.contentDatabases)
+      .where(
+        and(
+          eq(schema.contentDatabases.id, databaseId),
+          isNull(schema.contentDatabases.deletedAt),
+        ),
+      )
+      .limit(1);
+    if (database) await renumberDatabaseRows(db, database, now);
+  }
+
+  return documentIds;
+}
+
 async function deleteWhereIn<T>(
   items: T[],
   run: (batch: T[]) => Promise<unknown>,
@@ -171,6 +318,20 @@ export async function deleteDocumentRecursive(
 ): Promise<string[]> {
   const { documentIds, ownedDatabaseIds } =
     await collectDocumentSubtreeForDelete(db, id, ownerEmail);
+  return deleteCollectedDocuments(
+    db,
+    documentIds,
+    ownedDatabaseIds,
+    ownerEmail,
+  );
+}
+
+async function deleteCollectedDocuments(
+  db: ReturnType<typeof getDb>,
+  documentIds: string[],
+  ownedDatabaseIds: string[],
+  ownerEmail: string,
+): Promise<string[]> {
   await assertNotWorkspaceCatalogDocuments(db, documentIds, "deleted");
 
   const propertyDefinitionIds: string[] = [];
@@ -353,8 +514,72 @@ export async function deleteDocumentRecursive(
   return documentIds;
 }
 
+export async function deleteTrashedDocumentSubtree(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  ownerEmail: string,
+): Promise<string[]> {
+  const [root] = await db
+    .select({ id: schema.documents.id })
+    .from(schema.documents)
+    .where(
+      and(
+        eq(schema.documents.id, id),
+        eq(schema.documents.ownerEmail, ownerEmail),
+        eq(schema.documents.trashRootId, id),
+        isNotNull(schema.documents.trashedAt),
+      ),
+    )
+    .limit(1);
+  if (!root) {
+    throw new Error(
+      "Document must be in Trash and be a Trash root before permanent deletion",
+    );
+  }
+
+  const documentIds = (
+    await db
+      .select({ id: schema.documents.id })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.ownerEmail, ownerEmail),
+          eq(schema.documents.trashRootId, id),
+          isNotNull(schema.documents.trashedAt),
+        ),
+      )
+  ).map((document) => document.id);
+  const ownedDatabaseIds = await selectOwnedDatabaseIds(
+    db,
+    documentIds,
+    ownerEmail,
+  ).then((rows) => rows.map((database) => database.id));
+
+  await db
+    .update(schema.documents)
+    .set({ parentId: null, updatedAt: new Date().toISOString() })
+    .where(
+      and(
+        eq(schema.documents.ownerEmail, ownerEmail),
+        inArray(schema.documents.parentId, documentIds),
+        or(
+          isNull(schema.documents.trashRootId),
+          ne(schema.documents.trashRootId, id),
+        ),
+      ),
+    );
+
+  return deleteCollectedDocuments(
+    db,
+    documentIds,
+    ownedDatabaseIds,
+    ownerEmail,
+  );
+}
+
 export default defineAction({
-  description: "Delete a document and all its children recursively.",
+  description:
+    "Move a document and all its children to Trash. Use permanently-delete-document to destroy an item already in Trash.",
   schema: z.object({
     id: z.string().optional().describe("Document ID (required)"),
     databaseDocumentId: z
@@ -408,10 +633,12 @@ export default defineAction({
     if (systemDatabase?.systemRole) {
       throw new Error("System Content database documents cannot be deleted");
     }
-    const deleted = await deleteDocumentRecursive(
-      db,
-      id,
-      existing.ownerEmail as string,
+    const deleted = await db.transaction((tx) =>
+      trashDocumentSubtree(
+        tx as unknown as ReturnType<typeof getDb>,
+        id,
+        existing.ownerEmail as string,
+      ),
     );
 
     await writeAppState("refresh-signal", { ts: Date.now() });

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

@@ -46,6 +46,7 @@ export default defineAction({
             ? eq(schema.contentDatabaseItems.id, itemId)
             : eq(schema.contentDatabaseItems.documentId, documentId!),
           isNull(schema.contentDatabases.deletedAt),
+          isNull(schema.documents.trashedAt),
         ),
       );
 

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

@@ -70,7 +70,10 @@ export default defineAction({
         statusCode: 404,
       });
     }
-    if (await isSoftDeletedDatabaseDocument(args.id)) {
+    if (
+      access.resource.trashedAt ||
+      (await isSoftDeletedDatabaseDocument(args.id))
+    ) {
       throw Object.assign(new Error(`Document "${args.id}" not found`), {
         statusCode: 404,
       });

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

@@ -60,6 +60,7 @@ export default defineAction({
       .where(
         and(
           accessFilter(schema.documents, schema.documentShares),
+          isNull(schema.documents.trashedAt),
           documentDiscoveryFilter(),
           isNull(schema.contentDatabases.deletedAt),
           excludedDatabaseIds.size === 1

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

@@ -106,6 +106,7 @@ export default defineAction({
               accessFilter(schema.documents, schema.documentShares, context),
             ),
           ),
+          isNull(schema.documents.trashedAt),
           documentDiscoveryFilter({
             userEmail,
             orgIds: authorizedOrgIds,

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

@@ -34,6 +34,7 @@ export default defineAction({
         deletedAt: schema.contentDatabases.deletedAt,
         documentTitle: schema.documents.title,
         documentParentId: schema.documents.parentId,
+        documentTrashRootId: schema.documents.trashRootId,
       })
       .from(schema.contentDatabases)
       .innerJoin(
@@ -47,6 +48,10 @@ export default defineAction({
       .where(
         and(
           isNotNull(schema.contentDatabases.deletedAt),
+          or(
+            isNull(schema.documents.trashRootId),
+            eq(schema.documents.trashRootId, schema.documents.id),
+          ),
           or(
             and(
               isBlockOwned,
@@ -82,8 +87,9 @@ export default defineAction({
         ownerDocumentId: row.ownerDocumentId,
         deletedAt: row.deletedAt!,
         canPermanentlyDelete:
-          row.ownerDocumentId === null ||
-          row.documentParentId !== row.ownerDocumentId,
+          row.documentTrashRootId === row.documentId &&
+          (row.ownerDocumentId === null ||
+            row.documentParentId !== row.ownerDocumentId),
       })),
     };
   },

package/corpus/templates/content/actions/list-trashed-documents.ts

@@ -0,0 +1,50 @@
+import { defineAction } from "@agent-native/core";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, desc, eq, isNotNull, isNull } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import type { ListTrashedDocumentsResponse } from "../shared/api.js";
+
+export default defineAction({
+  description:
+    "List trashed page roots the current user can manage. Titles are returned only after document access filtering.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (): Promise<ListTrashedDocumentsResponse> => {
+    const rows = await getDb()
+      .select({
+        documentId: schema.documents.id,
+        title: schema.documents.title,
+        trashedAt: schema.documents.trashedAt,
+      })
+      .from(schema.documents)
+      .leftJoin(
+        schema.contentDatabases,
+        eq(schema.contentDatabases.documentId, schema.documents.id),
+      )
+      .where(
+        and(
+          isNotNull(schema.documents.trashedAt),
+          eq(schema.documents.trashRootId, schema.documents.id),
+          isNull(schema.contentDatabases.id),
+          accessFilter(
+            schema.documents,
+            schema.documentShares,
+            undefined,
+            "admin",
+          ),
+        ),
+      )
+      .orderBy(desc(schema.documents.trashedAt));
+
+    return {
+      documents: rows.map((row) => ({
+        documentId: row.documentId,
+        title: row.title.trim() || "Untitled",
+        trashedAt: row.trashedAt!,
+      })),
+    };
+  },
+});

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

@@ -0,0 +1,28 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { deleteTrashedDocumentSubtree } from "./delete-document.js";
+
+export default defineAction({
+  description:
+    "Permanently delete a document subtree that is already in Trash. This cannot be undone.",
+  schema: z.object({
+    id: z.string().describe("Trashed root document ID"),
+  }),
+  run: async ({ id }) => {
+    const access = await assertAccess("document", id, "admin");
+    const db = getDb();
+    const deleted = await db.transaction((tx) =>
+      deleteTrashedDocumentSubtree(
+        tx as unknown as ReturnType<typeof getDb>,
+        id,
+        access.resource.ownerEmail as string,
+      ),
+    );
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return { success: true, deleted: deleted.length };
+  },
+});

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

@@ -4,6 +4,7 @@ import { resolveAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
 import "../server/db/index.js";
+import { isSoftDeletedDatabaseDocument } from "./_database-utils.js";
 import { flushOpenDocumentEditorToSql } from "./_document-flush.js";
 
 /**
@@ -62,7 +63,13 @@ export default defineAction({
   publicAgent: { expose: true, readOnly: true, requiresAuth: true },
   run: async ({ id, format }) => {
     const access = await resolveAccess("document", id);
-    if (!access) throw new Error(`Document "${id}" not found`);
+    if (
+      !access ||
+      access.resource.trashedAt ||
+      (await isSoftDeletedDatabaseDocument(id))
+    ) {
+      throw new Error(`Document "${id}" not found`);
+    }
 
     // If a live Yjs collab session is open, the in-memory editor doc is fresher
     // than the SQL column. Ask the open editor to serialize + save, then wait
@@ -74,7 +81,13 @@ export default defineAction({
 
     // Re-resolve so we read the now-fresh row (and re-check access).
     const fresh = await resolveAccess("document", id);
-    if (!fresh) throw new Error(`Document "${id}" not found`);
+    if (
+      !fresh ||
+      fresh.resource.trashedAt ||
+      (await isSoftDeletedDatabaseDocument(id))
+    ) {
+      throw new Error(`Document "${id}" not found`);
+    }
     const doc = fresh.resource;
     const markdown = (doc.content as string) ?? "";
     const content = formatDocumentContent(markdown, format);

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

@@ -1,7 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { resolveAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq, isNotNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -9,6 +9,7 @@ import {
   assertContentDatabaseLifecycleAccess,
   collectInlineDatabaseOwnerBlockIds,
 } from "./_content-database-lifecycle.js";
+import { restoreDocumentSubtree } from "./delete-document.js";
 import pullDocumentAction from "./pull-document.js";
 
 async function shouldClearStaleInlineOwnership(args: {
@@ -47,16 +48,52 @@ export default defineAction({
       ownerBlockId: ownership.database.ownerBlockId,
     });
 
-    await db
-      .update(schema.contentDatabases)
-      .set({
-        deletedAt: null,
-        updatedAt: now,
-        ...(clearInlineOwnership
-          ? { ownerDocumentId: null, ownerBlockId: null }
-          : {}),
-      })
-      .where(eq(schema.contentDatabases.id, databaseId));
+    await db.transaction(async (tx) => {
+      const [backingDocument] = await tx
+        .select({
+          trashedAt: schema.documents.trashedAt,
+          trashRootId: schema.documents.trashRootId,
+        })
+        .from(schema.documents)
+        .where(eq(schema.documents.id, ownership.database.documentId))
+        .limit(1);
+      if (!backingDocument) {
+        throw new Error(`Database "${databaseId}" not found`);
+      }
+      if (
+        backingDocument.trashedAt &&
+        backingDocument.trashRootId !== ownership.database.documentId
+      ) {
+        throw new Error("Restore the parent Trash item instead");
+      }
+
+      const restoredDocumentIds = await restoreDocumentSubtree(
+        tx as unknown as ReturnType<typeof getDb>,
+        ownership.database.documentId,
+        ownership.database.ownerEmail,
+      );
+      if (
+        backingDocument.trashedAt &&
+        !restoredDocumentIds.includes(ownership.database.documentId)
+      ) {
+        throw new Error("Database backing page was not restored");
+      }
+      await tx
+        .update(schema.contentDatabases)
+        .set({
+          deletedAt: null,
+          updatedAt: now,
+          ...(clearInlineOwnership
+            ? { ownerDocumentId: null, ownerBlockId: null }
+            : {}),
+        })
+        .where(
+          and(
+            eq(schema.contentDatabases.id, databaseId),
+            isNotNull(schema.contentDatabases.deletedAt),
+          ),
+        );
+    });
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 

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

@@ -0,0 +1,28 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { restoreDocumentSubtree } from "./delete-document.js";
+
+export default defineAction({
+  description: "Restore a page subtree from Trash.",
+  schema: z.object({
+    id: z.string().describe("Trashed root document ID"),
+  }),
+  run: async ({ id }) => {
+    const access = await assertAccess("document", id, "admin");
+    const restored = await getDb().transaction((tx) =>
+      restoreDocumentSubtree(
+        tx as unknown as ReturnType<typeof getDb>,
+        id,
+        access.resource.ownerEmail as string,
+      ),
+    );
+    if (restored.length === 0) throw new Error("Document is not in Trash");
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+    return { success: true, restored: restored.length, documentId: id };
+  },
+});

package/corpus/templates/content/actions/search-documents.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { accessFilter } from "@agent-native/core/sharing";
-import { and, sql } from "drizzle-orm";
+import { and, isNull, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -74,6 +74,7 @@ export default defineAction({
       .where(
         and(
           accessFilter(schema.documents, schema.documentShares),
+          isNull(schema.documents.trashedAt),
           documentDiscoveryFilter(),
           sql`(${schema.documents.title} LIKE ${pattern} ESCAPE '\\' OR ${schema.documents.description} LIKE ${pattern} ESCAPE '\\' OR ${schema.documents.content} LIKE ${pattern} ESCAPE '\\')`,
         ),

package/corpus/templates/content/actions/view-screen.ts

@@ -4,7 +4,7 @@ import {
   readAppStateForCurrentTab,
 } from "@agent-native/core/application-state";
 import { accessFilter, resolveAccess } from "@agent-native/core/sharing";
-import { and, asc, inArray } from "drizzle-orm";
+import { and, asc, inArray, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -765,6 +765,7 @@ export default defineAction({
       .where(
         and(
           accessFilter(schema.documents, schema.documentShares),
+          isNull(schema.documents.trashedAt),
           documentDiscoveryFilter(),
         ),
       )