@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/content/server/routes/api/documents/[id]/move.patch.ts

@@ -1,180 +1,62 @@
-import {
-  getSession,
-  readBody,
-  runWithRequestContext,
-} from "@agent-native/core/server";
-import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, sql } from "drizzle-orm";
-import { defineEventHandler, createError } from "h3";
+import { ActionInputValidationError } from "@agent-native/core/action";
+import { getSession, runWithRequestContext } from "@agent-native/core/server";
+import { createError, defineEventHandler, readBody } from "h3";
 
-import {
-  documentsPositionScope,
-  nextAppendPosition,
-  withPositionLock,
-} from "../../../../../actions/_position-utils.js";
-import { getDb } from "../../../../db/index.js";
-import { schema } from "../../../../db/index.js";
-import {
-  parseDocumentFavorite,
-  parseDocumentHideFromSearch,
-} from "../../../../lib/documents.js";
-
-async function assertParentIsNotDescendant({
-  db,
-  ownerEmail,
-  id,
-  parentId,
-}: {
-  db: ReturnType<typeof getDb>;
-  ownerEmail: string;
-  id: string;
-  parentId: string | null | undefined;
-}) {
-  if (!parentId) return;
-  const queue = [id];
-  const visited = new Set<string>();
-
-  while (queue.length > 0) {
-    const currentId = queue.shift()!;
-    if (visited.has(currentId)) continue;
-    visited.add(currentId);
-
-    const children = await db
-      .select({ id: schema.documents.id })
-      .from(schema.documents)
-      .where(
-        and(
-          eq(schema.documents.ownerEmail, ownerEmail),
-          eq(schema.documents.parentId, currentId),
-        ),
-      );
-
-    for (const child of children) {
-      if (child.id === parentId) {
-        throw createError({
-          statusCode: 400,
-          statusMessage: "A document cannot be moved under one of its children",
-        });
-      }
-      queue.push(child.id);
-    }
-  }
-}
+import moveDocument from "../../../../../actions/move-document.js";
 
 export default defineEventHandler(async (event) => {
   const id = event.context.params!.id;
-  const body = await readBody(event);
   const session = await getSession(event).catch(() => null);
   if (!session?.email) {
     throw createError({ statusCode: 401, statusMessage: "Unauthenticated" });
   }
+  const body = await readBody<{ parentId?: unknown; position?: unknown }>(
+    event,
+  );
+  if (!body || (body.parentId === undefined && body.position === undefined)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "parentId or position is required",
+    });
+  }
 
-  return runWithRequestContext(
-    { userEmail: session.email, orgId: session.orgId },
-    async () => {
-      const access = await assertAccess("document", id, "editor");
-      const ownerEmail = access.resource.ownerEmail as string;
-      const db = getDb();
-
-      const existing = access.resource;
-
-      if (!existing) {
-        throw createError({
-          statusCode: 404,
-          statusMessage: "Document not found",
-        });
-      }
-
-      const updates: Record<string, unknown> = {
-        updatedAt: new Date().toISOString(),
-      };
-
-      if (body.parentId !== undefined) {
-        if (body.parentId) {
-          const parentAccess = await assertAccess(
-            "document",
-            body.parentId,
-            "editor",
-          );
-          if (parentAccess.resource.ownerEmail !== ownerEmail) {
-            throw createError({
-              statusCode: 400,
-              statusMessage: "Parent document must belong to the same owner",
-            });
-          }
-          await assertParentIsNotDescendant({
-            db,
-            ownerEmail,
+  // A reparent has to hold move-document's page-tree and row locks, or a
+  // concurrent move can close a cycle with it. `position` is move-document's
+  // index among the page's siblings, which it renumbers, not a stored value.
+  try {
+    return await runWithRequestContext(
+      { userEmail: session.email, orgId: session.orgId },
+      () =>
+        moveDocument.run(
+          {
             id,
-            parentId: body.parentId,
-          });
-        }
-        updates.parentId = body.parentId;
-      }
-
-      const applyUpdate = () =>
-        db
-          .update(schema.documents)
-          .set(updates)
-          .where(
-            and(
-              eq(schema.documents.id, id),
-              eq(schema.documents.ownerEmail, ownerEmail),
-            ),
-          );
-
-      if (body.position !== undefined) {
-        updates.position = body.position;
-        await applyUpdate();
-      } else if (body.parentId !== undefined) {
-        const parentId = body.parentId;
-        await withPositionLock(
-          documentsPositionScope(ownerEmail, parentId),
-          async () => {
-            const maxPos = await db
-              .select({ max: sql<unknown>`COALESCE(MAX(position), -1)` })
-              .from(schema.documents)
-              .where(
-                parentId
-                  ? and(
-                      eq(schema.documents.ownerEmail, ownerEmail),
-                      eq(schema.documents.parentId, parentId),
-                    )
-                  : and(
-                      eq(schema.documents.ownerEmail, ownerEmail),
-                      sql`parent_id IS NULL`,
-                    ),
-              );
-            updates.position = nextAppendPosition(maxPos[0]?.max);
-            await applyUpdate();
+            parentId: body.parentId as string | null | undefined,
+            position: body.position as number | undefined,
           },
-        );
-      } else {
-        await applyUpdate();
-      }
-
-      const [doc] = await db
-        .select()
-        .from(schema.documents)
-        .where(
-          and(
-            eq(schema.documents.id, id),
-            eq(schema.documents.ownerEmail, ownerEmail),
-          ),
-        );
-
-      return {
-        id: doc.id,
-        parentId: doc.parentId,
-        title: doc.title,
-        content: doc.content,
-        icon: doc.icon,
-        position: doc.position,
-        isFavorite: parseDocumentFavorite(doc.isFavorite),
-        hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
-        createdAt: doc.createdAt,
-        updatedAt: doc.updatedAt,
-      };
-    },
-  );
+          {
+            caller: "http",
+            userEmail: session.email,
+            orgId: session.orgId,
+            actionName: "move-document",
+          },
+        ),
+    );
+  } catch (error) {
+    // h3 sends a thrown error that isn't its own as a bare status, with no
+    // message, so a refusal keeps its message and errorCode only this way.
+    // The status is move-document's: 409 for a parent with another owner,
+    // space or section, as duplicate-page and moves between spaces return.
+    if (error instanceof ActionInputValidationError) {
+      throw createError({ statusCode: 400, statusMessage: error.message });
+    }
+    const statusCode = (error as { statusCode?: unknown }).statusCode;
+    if (typeof statusCode !== "number" || statusCode < 400 || statusCode >= 500)
+      throw error;
+    const errorCode = (error as { errorCode?: unknown }).errorCode;
+    throw createError({
+      statusCode,
+      statusMessage: (error as Error).message,
+      ...(typeof errorCode === "string" ? { data: { errorCode } } : {}),
+    });
+  }
 });

package/corpus/templates/content/shared/api.ts

@@ -405,6 +405,8 @@ export interface ContentDatabaseFilter {
   value: string;
   filterGroupId?: string;
   parentFilterGroupId?: string;
+  filterGroupMode?: ContentDatabaseFilterMode;
+  parentFilterGroupMode?: ContentDatabaseFilterMode;
 }
 
 export interface ContentDatabaseTableQuery {
@@ -453,6 +455,22 @@ export interface ContentDatabaseFormQuestion {
   required: boolean;
 }
 
+export type ContentDatabaseItemLeadingKind =
+  | "none"
+  | "page_icon"
+  | "checkbox"
+  | "status";
+export type ContentDatabaseItemTitleWeight = "regular" | "medium" | "bold";
+
+/** Which property fills each part of a list row. */
+export interface ContentDatabaseItemLayout {
+  leading: { kind: ContentDatabaseItemLeadingKind; propertyId: string | null };
+  titleWeight: ContentDatabaseItemTitleWeight;
+  line2: { propertyId: string | null; lines: 1 | 2 | 3 };
+  line3: string[];
+  trailing: string[];
+}
+
 export interface ContentDatabaseView {
   id: string;
   name: string;
@@ -477,6 +495,8 @@ export interface ContentDatabaseView {
   rowDensity?: ContentDatabaseRowDensity;
   openPagesIn?: ContentDatabaseOpenPagesIn;
   formQuestions?: ContentDatabaseFormQuestion[];
+  /** List rows only. Null or absent keeps the default rows. */
+  itemLayout?: ContentDatabaseItemLayout | null;
 }
 
 export interface ContentDatabaseViewConfig {

package/corpus/templates/content/shared/blocks-fields-manifest.ts

@@ -0,0 +1,106 @@
+import type { BlocksFieldExport } from "./document-export.js";
+
+// A page export carries its Blocks fields, with their block identities, in a
+// manifest a reader never sees: a comment ending Markdown, a script in HTML.
+
+const MARKDOWN_MANIFEST_START = "<!-- agent-native-blocks:";
+const MARKDOWN_MANIFEST_END = " -->";
+
+export interface ExportManifestField {
+  name: string;
+  /** Null in exports made before the manifest named the primary field. */
+  primary: boolean | null;
+  markdown: string;
+}
+
+export type ExportManifest =
+  | { kind: "absent" }
+  | { kind: "read"; fields: ExportManifestField[] }
+  | { kind: "unreadable"; reason: string };
+
+export function serializeBlocksFieldsManifest(
+  fields: BlocksFieldExport[],
+): string {
+  return JSON.stringify({ version: 1, fields })
+    .replace(/</g, "\\u003c")
+    .replace(/>/g, "\\u003e")
+    .replace(/&/g, "\\u0026")
+    .replace(/--/g, "\\u002d\\u002d");
+}
+
+export function markdownWithBlocksFieldsManifest(
+  markdown: string,
+  manifest: string,
+): string {
+  return `${markdown.trimEnd()}\n\n${MARKDOWN_MANIFEST_START}${manifest}${MARKDOWN_MANIFEST_END}\n`;
+}
+
+export function htmlWithBlocksFieldsManifest(
+  html: string,
+  manifest: string,
+): string {
+  return html.replace(
+    "</body>",
+    `<script type="application/json" id="agent-native-blocks">${manifest}</script>\n</body>`,
+  );
+}
+
+/** Splits the manifest a Markdown export ends with off its body. */
+export function splitMarkdownExportManifest(text: string): {
+  body: string;
+  manifest: ExportManifest;
+} {
+  const start = text.lastIndexOf(MARKDOWN_MANIFEST_START);
+  const line = start < 0 ? "" : text.slice(start).trimEnd();
+  // Only the last line can be the manifest; the marker anywhere else is text.
+  if (
+    start < 0 ||
+    (start > 0 && text[start - 1] !== "\n") ||
+    line.includes("\n")
+  )
+    return { body: text, manifest: { kind: "absent" } };
+  return {
+    body: `${text.slice(0, start).trimEnd()}\n`,
+    manifest: line.endsWith(MARKDOWN_MANIFEST_END)
+      ? readBlocksFieldsManifest(
+          line.slice(
+            MARKDOWN_MANIFEST_START.length,
+            -MARKDOWN_MANIFEST_END.length,
+          ),
+        )
+      : { kind: "unreadable", reason: "the manifest comment is not closed" },
+  };
+}
+
+function readBlocksFieldsManifest(json: string): ExportManifest {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error) {
+    return {
+      kind: "unreadable",
+      reason: error instanceof Error ? error.message : String(error),
+    };
+  }
+  const manifest = parsed as { version?: unknown; fields?: unknown } | null;
+  if (manifest?.version !== 1 || !Array.isArray(manifest.fields))
+    return { kind: "unreadable", reason: "not a version 1 manifest" };
+  const fields: ExportManifestField[] = [];
+  for (const entry of manifest.fields as unknown[]) {
+    const field = entry as Partial<Record<keyof BlocksFieldExport, unknown>>;
+    if (typeof field?.name !== "string" || typeof field.markdown !== "string")
+      return { kind: "unreadable", reason: "a field has no name or Markdown" };
+    // Only a manifest written before the flag existed lacks it.
+    if (field.primary !== undefined && typeof field.primary !== "boolean")
+      return {
+        kind: "unreadable",
+        reason: "a field's primary flag is not true or false",
+      };
+    fields.push({
+      name: field.name,
+      primary: field.primary ?? null,
+      markdown: field.markdown,
+    });
+  }
+  return { kind: "read", fields };
+}