@agent-native/core 0.84.0 → 0.84.1

package/corpus/templates/content/actions/_database-row-batch.ts

@@ -0,0 +1,230 @@
+import { and, asc, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export const DATABASE_ROW_BATCH_LIMIT = 100;
+
+export const databaseRowBatchSchema = z
+  .object({
+    databaseId: z.string().optional().describe("Content database ID"),
+    documentId: z
+      .string()
+      .optional()
+      .describe("Content database backing document ID"),
+    itemIds: z
+      .array(z.string())
+      .max(DATABASE_ROW_BATCH_LIMIT)
+      .optional()
+      .describe(
+        'Native JSON array of database row item IDs to mutate in one batch, for example ["item_1", "item_2"].',
+      ),
+    documentIds: z
+      .array(z.string())
+      .max(DATABASE_ROW_BATCH_LIMIT)
+      .optional()
+      .describe(
+        'Native JSON array of database row document IDs to mutate in one batch, for example ["doc_1", "doc_2"].',
+      ),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.databaseId && !value.documentId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Either databaseId or documentId is required.",
+      });
+    }
+    const total =
+      (value.itemIds?.length ?? 0) + (value.documentIds?.length ?? 0);
+    if (total === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "At least one itemId or documentId is required.",
+      });
+    }
+    if (total > DATABASE_ROW_BATCH_LIMIT) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Database row batch is limited to ${DATABASE_ROW_BATCH_LIMIT} rows.`,
+      });
+    }
+  });
+
+export type DatabaseRowBatchInput = z.infer<typeof databaseRowBatchSchema>;
+
+export type DatabaseRowBatchRow = {
+  item: typeof schema.contentDatabaseItems.$inferSelect;
+  database: typeof schema.contentDatabases.$inferSelect;
+  document: typeof schema.documents.$inferSelect;
+};
+
+function findDuplicates(values: string[]) {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) duplicates.add(value);
+    seen.add(value);
+  }
+  return [...duplicates];
+}
+
+function positionCaseSql(
+  idColumn: unknown,
+  fallbackColumn: unknown,
+  orderedIds: string[],
+) {
+  const cases = orderedIds.map((id, index) => sql`WHEN ${id} THEN ${index}`);
+  return sql<number>`CASE ${idColumn} ${sql.join(cases, sql` `)} ELSE ${fallbackColumn} END`;
+}
+
+export async function resolveDatabaseRowsForBatch(
+  input: DatabaseRowBatchInput,
+): Promise<{
+  database: typeof schema.contentDatabases.$inferSelect;
+  rows: DatabaseRowBatchRow[];
+}> {
+  const itemIds = input.itemIds ?? [];
+  const documentIds = input.documentIds ?? [];
+  const requestedCount = itemIds.length + documentIds.length;
+  if (!input.databaseId && !input.documentId) {
+    throw new Error("Either databaseId or documentId is required.");
+  }
+  if (requestedCount === 0) {
+    throw new Error("At least one itemId or documentId is required.");
+  }
+  if (requestedCount > DATABASE_ROW_BATCH_LIMIT) {
+    throw new Error(
+      `Database row batch is limited to ${DATABASE_ROW_BATCH_LIMIT} rows.`,
+    );
+  }
+  const duplicateItemIds = findDuplicates(itemIds);
+  const duplicateDocumentIds = findDuplicates(documentIds);
+  if (duplicateItemIds.length > 0 || duplicateDocumentIds.length > 0) {
+    throw new Error("Duplicate database row IDs are not allowed in one batch.");
+  }
+
+  const db = getDb();
+  const [database] = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        input.databaseId
+          ? eq(schema.contentDatabases.id, input.databaseId)
+          : undefined,
+        input.documentId
+          ? eq(schema.contentDatabases.documentId, input.documentId)
+          : undefined,
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    );
+
+  if (!database) throw new Error("Database not found.");
+
+  const rowPredicates = [];
+  if (itemIds.length > 0) {
+    rowPredicates.push(inArray(schema.contentDatabaseItems.id, itemIds));
+  }
+  if (documentIds.length > 0) {
+    rowPredicates.push(
+      inArray(schema.contentDatabaseItems.documentId, documentIds),
+    );
+  }
+
+  const requestedRows = await db
+    .select({
+      item: schema.contentDatabaseItems,
+      database: schema.contentDatabases,
+      document: schema.documents,
+    })
+    .from(schema.contentDatabaseItems)
+    .innerJoin(
+      schema.contentDatabases,
+      eq(schema.contentDatabases.id, schema.contentDatabaseItems.databaseId),
+    )
+    .innerJoin(
+      schema.documents,
+      eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+    )
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        rowPredicates.length === 1 ? rowPredicates[0] : or(...rowPredicates),
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    )
+    .orderBy(asc(schema.contentDatabaseItems.position));
+
+  const itemIdMatches = new Set(requestedRows.map((row) => row.item.id));
+  const documentIdMatches = new Set(
+    requestedRows.map((row) => row.item.documentId),
+  );
+  const missingItemIds = itemIds.filter((id) => !itemIdMatches.has(id));
+  const missingDocumentIds = documentIds.filter(
+    (id) => !documentIdMatches.has(id),
+  );
+  if (missingItemIds.length > 0 || missingDocumentIds.length > 0) {
+    throw new Error("All requested rows must exist in the target database.");
+  }
+
+  if (requestedRows.length !== requestedCount) {
+    throw new Error("Duplicate database row references are not allowed.");
+  }
+
+  const rowIds = requestedRows.map((row) => row.item.id);
+  if (new Set(rowIds).size !== rowIds.length) {
+    throw new Error("Duplicate database row references are not allowed.");
+  }
+
+  return { database, rows: requestedRows };
+}
+
+export async function renumberDatabaseRows(
+  db: ReturnType<typeof getDb>,
+  database: typeof schema.contentDatabases.$inferSelect,
+  now: string,
+) {
+  const rows = await db
+    .select()
+    .from(schema.contentDatabaseItems)
+    .where(eq(schema.contentDatabaseItems.databaseId, database.id))
+    .orderBy(asc(schema.contentDatabaseItems.position));
+  if (rows.length === 0) return;
+
+  const itemIds = rows.map((row) => row.id);
+  const documentIds = rows.map((row) => row.documentId);
+  await db
+    .update(schema.contentDatabaseItems)
+    .set({
+      position: positionCaseSql(
+        schema.contentDatabaseItems.id,
+        schema.contentDatabaseItems.position,
+        itemIds,
+      ),
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        inArray(schema.contentDatabaseItems.id, itemIds),
+      ),
+    );
+
+  await db
+    .update(schema.documents)
+    .set({
+      position: positionCaseSql(
+        schema.documents.id,
+        schema.documents.position,
+        documentIds,
+      ),
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.documents.ownerEmail, database.ownerEmail),
+        eq(schema.documents.parentId, database.documentId),
+        inArray(schema.documents.id, documentIds),
+      ),
+    );
+}

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

@@ -285,8 +285,8 @@ export async function isSoftDeletedDatabaseDocument(documentId: string) {
 export async function getDatabaseByDocumentId(
   documentId: string,
   options: { includeDeleted?: boolean } = {},
+  db = getDb(),
 ) {
-  const db = getDb();
   const clauses = [eq(schema.contentDatabases.documentId, documentId)];
   if (!options.includeDeleted) {
     clauses.push(isNull(schema.contentDatabases.deletedAt));
@@ -301,8 +301,8 @@ export async function getDatabaseByDocumentId(
 export async function getDatabaseItemByDocumentId(
   documentId: string,
   options: { includeDeleted?: boolean } = {},
+  db = getDb(),
 ) {
-  const db = getDb();
   const clauses = [eq(schema.contentDatabaseItems.documentId, documentId)];
   if (!options.includeDeleted) {
     clauses.push(isNull(schema.contentDatabases.deletedAt));
@@ -332,11 +332,15 @@ export async function getDatabaseItemByDocumentId(
 export async function deleteDatabaseDataForDocument(
   documentId: string,
   ownerEmail: string,
+  db = getDb(),
 ) {
-  const db = getDb();
-  const database = await getDatabaseByDocumentId(documentId, {
-    includeDeleted: true,
-  });
+  const database = await getDatabaseByDocumentId(
+    documentId,
+    {
+      includeDeleted: true,
+    },
+    db,
+  );
   if (database) {
     const definitions = await db
       .select({ id: schema.documentPropertyDefinitions.id })
@@ -395,9 +399,13 @@ export async function deleteDatabaseDataForDocument(
       .where(eq(schema.contentDatabases.id, database.id));
   }
 
-  const item = await getDatabaseItemByDocumentId(documentId, {
-    includeDeleted: true,
-  });
+  const item = await getDatabaseItemByDocumentId(
+    documentId,
+    {
+      includeDeleted: true,
+    },
+    db,
+  );
   if (item) {
     await db
       .delete(schema.contentDatabaseBodyHydrationQueue)

package/corpus/templates/content/actions/_notion-action-utils.ts

@@ -0,0 +1,26 @@
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+
+export function getCurrentNotionOwner() {
+  const owner = getRequestUserEmail();
+  if (!owner) throw new Error("no authenticated user");
+  return owner;
+}
+
+export async function getNotionDocumentOwner(documentId: string) {
+  const userEmail = getCurrentNotionOwner();
+  await assertAccess("document", documentId, "editor", {
+    userEmail,
+    orgId: getRequestOrgId(),
+  });
+  return userEmail;
+}
+
+export function resolveDocumentId(args: { documentId?: string; id?: string }) {
+  const documentId = args.documentId || args.id;
+  if (!documentId) throw new Error("documentId is required");
+  return documentId;
+}

package/corpus/templates/content/actions/connect-notion-status.ts

@@ -1,21 +1,30 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
+import { resolveSecret } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { getNotionConnectionForOwner } from "../server/lib/notion.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "Check Notion connection status for the current user.",
   schema: z.object({}),
-  http: false,
+  http: { method: "GET" },
   run: async () => {
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
+    const owner = getCurrentNotionOwner();
     const connection = await getNotionConnectionForOwner(owner);
+    const hasOAuthCredentials = Boolean(
+      (await resolveSecret("NOTION_CLIENT_ID")) &&
+      (await resolveSecret("NOTION_CLIENT_SECRET")),
+    );
+
     return {
       connected: Boolean(connection),
       workspaceName: connection?.workspaceName ?? null,
       workspaceId: connection?.workspaceId ?? null,
+      authUrl: null,
+      error:
+        connection || hasOAuthCredentials ? undefined : "missing_credentials",
+      mode: connection ? ("oauth" as const) : null,
     };
   },
 });

package/corpus/templates/content/actions/create-and-link-notion-page.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { createAndLinkNotionPage } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Create a Notion page from a Content document and link it.",
+  schema: z.object({
+    documentId: z.string().optional().describe("Document ID (required)"),
+    id: z.string().optional().describe("Alias for --documentId"),
+    parentPageIdOrUrl: z.string().optional(),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
+    return createAndLinkNotionPage(owner, documentId, args.parentPageIdOrUrl);
+  },
+});

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

@@ -0,0 +1,55 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+
+import { getDb } from "../server/db/index.js";
+import {
+  databaseRowBatchSchema,
+  renumberDatabaseRows,
+  resolveDatabaseRowsForBatch,
+} from "./_database-row-batch.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+import { deleteDocumentRecursive } from "./delete-document.js";
+
+export default defineAction({
+  description:
+    "Delete multiple page rows from a content database in one atomic batch. Use this for two or more selected/named rows instead of looping delete-document.",
+  schema: databaseRowBatchSchema,
+  run: async (args) => {
+    const db = getDb();
+    const { database, rows } = await resolveDatabaseRowsForBatch(args);
+
+    await assertAccess("document", database.documentId, "editor");
+    for (const row of rows) {
+      await assertAccess("document", row.document.id, "admin");
+    }
+
+    const deletedItemIds = rows.map((row) => row.item.id);
+    const deletedDocumentIds = rows.map((row) => row.document.id);
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      for (const row of rows) {
+        await deleteDocumentRecursive(
+          tx as unknown as ReturnType<typeof getDb>,
+          row.document.id,
+          row.document.ownerEmail,
+        );
+      }
+      await renumberDatabaseRows(
+        tx as unknown as ReturnType<typeof getDb>,
+        database,
+        now,
+      );
+    });
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      deletedItemIds,
+      deletedDocumentIds,
+      deletedCount: deletedItemIds.length,
+    };
+  },
+});

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

@@ -12,7 +12,7 @@ import {
   isContentLocalFileMode,
 } from "./_local-file-documents.js";
 
-async function deleteRecursive(
+export async function deleteDocumentRecursive(
   db: ReturnType<typeof getDb>,
   id: string,
   ownerEmail: string,
@@ -29,11 +29,11 @@ async function deleteRecursive(
 
   const deleted: string[] = [];
   for (const child of children) {
-    deleted.push(...(await deleteRecursive(db, child.id, ownerEmail)));
+    deleted.push(...(await deleteDocumentRecursive(db, child.id, ownerEmail)));
   }
 
   // Delete database membership/schema, sync links, versions, shares, then document.
-  await deleteDatabaseDataForDocument(id, ownerEmail);
+  await deleteDatabaseDataForDocument(id, ownerEmail, db);
   await db
     .delete(schema.documentSyncLinks)
     .where(
@@ -86,7 +86,7 @@ export default defineAction({
     const existing = access.resource;
 
     const db = getDb();
-    const deleted = await deleteRecursive(
+    const deleted = await deleteDocumentRecursive(
       db,
       id,
       existing.ownerEmail as string,

package/corpus/templates/content/actions/disconnect-notion.ts

@@ -0,0 +1,16 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { disconnectNotionForOwner } from "../server/lib/notion.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Disconnect the current user's Notion workspace.",
+  schema: z.object({}),
+  http: { method: "POST" },
+  run: async () => {
+    const owner = getCurrentNotionOwner();
+    const deleted = await disconnectNotionForOwner(owner);
+    return { success: true, deleted };
+  },
+});

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

@@ -11,7 +11,7 @@ import { nanoid } from "./_property-utils.js";
 
 export default defineAction({
   description:
-    "Duplicate a page row in a content database, including stored property values.",
+    "Duplicate exactly one page row in a content database, including stored property values. For two or more rows, use duplicate-database-items once instead of looping this action.",
   schema: z.object({
     itemId: z.string().optional().describe("Database item ID"),
     documentId: z.string().optional().describe("Database row document ID"),

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

@@ -0,0 +1,191 @@
+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, gte, inArray, sql } from "drizzle-orm";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  databaseRowBatchSchema,
+  resolveDatabaseRowsForBatch,
+} from "./_database-row-batch.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+import { nanoid } from "./_property-utils.js";
+
+export default defineAction({
+  description:
+    "Duplicate multiple page rows in a content database in one atomic batch. Use this for two or more selected/named rows instead of looping duplicate-database-item.",
+  schema: databaseRowBatchSchema,
+  run: async (args) => {
+    const db = getDb();
+    const { database, rows } = await resolveDatabaseRowsForBatch(args);
+
+    await assertAccess("document", database.documentId, "editor");
+    for (const row of rows) {
+      await assertAccess("document", row.document.id, "viewer");
+    }
+
+    const sourceDocumentIds = rows.map((row) => row.document.id);
+    const sourceItemIds = rows.map((row) => row.item.id);
+    const now = new Date().toISOString();
+    const insertionPosition =
+      Math.max(...rows.map((row) => row.item.position)) + 1;
+    const currentUserEmail = getRequestUserEmail() ?? database.ownerEmail;
+
+    const values =
+      sourceDocumentIds.length > 0
+        ? await db
+            .select()
+            .from(schema.documentPropertyValues)
+            .where(
+              inArray(
+                schema.documentPropertyValues.documentId,
+                sourceDocumentIds,
+              ),
+            )
+        : [];
+    const valuesByDocumentId = new Map<
+      string,
+      Array<typeof schema.documentPropertyValues.$inferSelect>
+    >();
+    for (const value of values) {
+      const list = valuesByDocumentId.get(value.documentId) ?? [];
+      list.push(value);
+      valuesByDocumentId.set(value.documentId, list);
+    }
+
+    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 duplicates = rows.map((row, index) => ({
+      sourceItemId: row.item.id,
+      sourceDocumentId: row.document.id,
+      duplicatedItemId: nanoid(),
+      duplicatedDocumentId: nanoid(),
+      position: insertionPosition + index,
+      row,
+    }));
+
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.contentDatabaseItems)
+        .set({
+          position: sql`${schema.contentDatabaseItems.position} + ${duplicates.length}`,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            eq(schema.contentDatabaseItems.databaseId, database.id),
+            gte(schema.contentDatabaseItems.position, insertionPosition),
+          ),
+        );
+
+      await tx
+        .update(schema.documents)
+        .set({
+          position: sql`${schema.documents.position} + ${duplicates.length}`,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            eq(schema.documents.ownerEmail, database.ownerEmail),
+            eq(schema.documents.parentId, database.documentId),
+            gte(schema.documents.position, insertionPosition),
+          ),
+        );
+
+      await tx.insert(schema.documents).values(
+        duplicates.map((duplicate) => ({
+          id: duplicate.duplicatedDocumentId,
+          ownerEmail: duplicate.row.document.ownerEmail,
+          orgId: duplicate.row.document.orgId,
+          parentId: database.documentId,
+          title: `Copy of ${duplicate.row.document.title.trim() || "Untitled"}`,
+          content: duplicate.row.document.content,
+          icon: duplicate.row.document.icon,
+          position: duplicate.position,
+          isFavorite: 0,
+          hideFromSearch: duplicate.row.document.hideFromSearch,
+          visibility: duplicate.row.document.visibility,
+          createdAt: now,
+          updatedAt: now,
+        })),
+      );
+
+      await tx.insert(schema.contentDatabaseItems).values(
+        duplicates.map((duplicate) => ({
+          id: duplicate.duplicatedItemId,
+          ownerEmail: duplicate.row.item.ownerEmail,
+          orgId: duplicate.row.item.orgId,
+          databaseId: database.id,
+          documentId: duplicate.duplicatedDocumentId,
+          position: duplicate.position,
+          createdAt: now,
+          updatedAt: now,
+        })),
+      );
+
+      const duplicatedValues = duplicates.flatMap((duplicate) =>
+        (valuesByDocumentId.get(duplicate.sourceDocumentId) ?? []).map(
+          (value) => ({
+            id: nanoid(),
+            ownerEmail: duplicate.row.document.ownerEmail,
+            documentId: duplicate.duplicatedDocumentId,
+            propertyId: value.propertyId,
+            valueJson: value.valueJson,
+            createdAt: now,
+            updatedAt: now,
+          }),
+        ),
+      );
+      if (duplicatedValues.length > 0) {
+        await tx.insert(schema.documentPropertyValues).values(duplicatedValues);
+      }
+
+      if (inheritedShares.length > 0) {
+        await tx.insert(schema.documentShares).values(
+          duplicates.flatMap((duplicate) =>
+            inheritedShares.map((share) => ({
+              id: nanoid(),
+              resourceId: duplicate.duplicatedDocumentId,
+              principalType: share.principalType,
+              principalId: share.principalId,
+              role: share.role,
+              createdBy: currentUserEmail,
+              createdAt: now,
+            })),
+          ),
+        );
+      }
+    });
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      duplicatedItemId: duplicates[0]?.duplicatedItemId,
+      duplicatedDocumentId: duplicates[0]?.duplicatedDocumentId,
+      duplicatedItemIds: duplicates.map(
+        (duplicate) => duplicate.duplicatedItemId,
+      ),
+      duplicatedDocumentIds: duplicates.map(
+        (duplicate) => duplicate.duplicatedDocumentId,
+      ),
+      sourceItemIds,
+      sourceDocumentIds,
+      sourceToDuplicate: duplicates.map((duplicate) => ({
+        sourceItemId: duplicate.sourceItemId,
+        sourceDocumentId: duplicate.sourceDocumentId,
+        duplicatedItemId: duplicate.duplicatedItemId,
+        duplicatedDocumentId: duplicate.duplicatedDocumentId,
+      })),
+      duplicatedCount: duplicates.length,
+    };
+  },
+});