@agent-native/core 0.114.5 → 0.114.6

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

@@ -22,7 +22,10 @@ import type {
   ContentDatabaseResponse,
 } from "../shared/api.js";
 import { favoriteDocumentIds } from "./_content-favorites.js";
-import { listContentOrganizationMemberships } from "./_content-space-access.js";
+import {
+  listContentOrganizationMemberships,
+  normalizeContentSpaceEmail,
+} from "./_content-space-access.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
 import {
   applyFederatedOverlayValues,
@@ -81,6 +84,8 @@ export const contentDatabaseListDocumentSelection = {
   sourcePath: schema.documents.sourcePath,
   sourceRootPath: schema.documents.sourceRootPath,
   sourceUpdatedAt: schema.documents.sourceUpdatedAt,
+  trashedAt: schema.documents.trashedAt,
+  trashRootId: schema.documents.trashRootId,
   visibility: schema.documents.visibility,
   ownerEmail: schema.documents.ownerEmail,
   orgId: schema.documents.orgId,
@@ -300,9 +305,14 @@ export async function getContentDatabaseResponse(
 
   const { limit, offset } = normalizeContentDatabasePageOptions(options);
   const userEmail = getRequestUserEmail();
+  const normalizedUserEmail = userEmail
+    ? normalizeContentSpaceEmail(userEmail)
+    : null;
   const activeOrgId = getRequestOrgId();
   const authorizedOrgIds =
-    database.systemRole === "favorites" && userEmail
+    (database.systemRole === "favorites" ||
+      database.systemRole === "workspaces") &&
+    userEmail
       ? [
           ...new Set([
             ...(await listContentOrganizationMemberships(userEmail)).map(
@@ -312,6 +322,45 @@ export async function getContentDatabaseResponse(
           ]),
         ]
       : [];
+  const workspacesVisibleDocumentIds =
+    database.systemRole === "workspaces" && normalizedUserEmail
+      ? (
+          await db
+            .select({
+              documentId: schema.contentSpaceCatalogItems.documentId,
+              ownerEmail: schema.contentSpaces.ownerEmail,
+              orgId: schema.contentSpaces.orgId,
+            })
+            .from(schema.contentSpaceCatalogItems)
+            .innerJoin(
+              schema.contentSpaces,
+              eq(
+                schema.contentSpaces.id,
+                schema.contentSpaceCatalogItems.spaceId,
+              ),
+            )
+            .where(
+              and(
+                eq(
+                  schema.contentSpaceCatalogItems.catalogDatabaseId,
+                  databaseId,
+                ),
+                eq(
+                  schema.contentSpaceCatalogItems.ownerEmail,
+                  normalizedUserEmail,
+                ),
+                isNull(schema.contentSpaces.archivedAt),
+              ),
+            )
+        )
+          .filter(
+            (row) =>
+              normalizeContentSpaceEmail(row.ownerEmail) ===
+                normalizedUserEmail ||
+              (!!row.orgId && authorizedOrgIds.includes(row.orgId)),
+          )
+          .map((row) => row.documentId)
+      : null;
   const favoritesVisibleDocumentIds =
     database.systemRole === "favorites" && userEmail
       ? (
@@ -331,6 +380,7 @@ export async function getContentDatabaseResponse(
                     }),
                   ),
                 ),
+                isNull(schema.documents.trashedAt),
                 documentDiscoveryFilter({
                   userEmail,
                   orgIds: authorizedOrgIds,
@@ -351,6 +401,11 @@ export async function getContentDatabaseResponse(
       : undefined;
   const visibleItemFilter = and(
     eq(schema.contentDatabaseItems.databaseId, databaseId),
+    sql`exists (
+      select 1 from ${schema.documents}
+      where ${schema.documents.id} = ${schema.contentDatabaseItems.documentId}
+        and ${schema.documents.trashedAt} is null
+    )`,
     organizationFilesItemFilter,
     favoritesVisibleDocumentIds
       ? favoritesVisibleDocumentIds.length > 0
@@ -360,6 +415,14 @@ export async function getContentDatabaseResponse(
           )
         : sql`1 = 0`
       : undefined,
+    workspacesVisibleDocumentIds
+      ? workspacesVisibleDocumentIds.length > 0
+        ? inArray(
+            schema.contentDatabaseItems.documentId,
+            workspacesVisibleDocumentIds,
+          )
+        : sql`1 = 0`
+      : undefined,
   );
   const [itemCount] = await db
     .select({ count: sql<number>`COUNT(*)` })
@@ -388,23 +451,28 @@ export async function getContentDatabaseResponse(
                 schema.documents.id,
                 items.map((item) => item.documentId),
               ),
+              isNull(schema.documents.trashedAt),
               database.systemRole === "favorites"
                 ? favoritesVisibleDocumentIds?.length
                   ? inArray(schema.documents.id, favoritesVisibleDocumentIds)
                   : sql`1 = 0`
-                : database.systemRole === "files" && database.orgId
-                  ? and(
-                      eq(schema.documents.orgId, database.orgId),
-                      or(
-                        eq(schema.documents.visibility, "org"),
-                        eq(schema.documents.visibility, "public"),
-                      ),
-                      or(
-                        eq(schema.documents.hideFromSearch, 0),
-                        isNull(schema.documents.hideFromSearch),
-                      ),
-                    )
-                  : eq(schema.documents.ownerEmail, database.ownerEmail),
+                : database.systemRole === "workspaces"
+                  ? workspacesVisibleDocumentIds?.length
+                    ? inArray(schema.documents.id, workspacesVisibleDocumentIds)
+                    : sql`1 = 0`
+                  : database.systemRole === "files" && database.orgId
+                    ? and(
+                        eq(schema.documents.orgId, database.orgId),
+                        or(
+                          eq(schema.documents.visibility, "org"),
+                          eq(schema.documents.visibility, "public"),
+                        ),
+                        or(
+                          eq(schema.documents.hideFromSearch, 0),
+                          isNull(schema.documents.hideFromSearch),
+                        ),
+                      )
+                    : eq(schema.documents.ownerEmail, database.ownerEmail),
             ),
           )
       : [];

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

@@ -41,6 +41,9 @@ export default defineAction({
         ),
       );
     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 access = await assertAccess(
       "document",

package/corpus/templates/content/actions/connect-local-folder-source.ts

@@ -51,6 +51,7 @@ export default defineAction({
       .optional()
       .default(false)
       .describe("Create a separate private Content space for this folder"),
+    propertyValues: z.record(z.string(), z.unknown()).optional(),
     truthPolicy: truthPolicySchema.describe(
       "Whether Content, the folder, or reviewed conflict resolution is authoritative",
     ),
@@ -130,7 +131,7 @@ export default defineAction({
       const provisioned = await provisionSourceBackedContentSpace(
         db,
         userEmail,
-        { connectionId, name: label },
+        { connectionId, name: label, propertyValues: args.propertyValues },
       );
       targetSpaceId = provisioned.spaceId;
       targetDatabaseId = provisioned.filesDatabaseId;

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 };
+  },
+});