@agent-native/core 0.114.0 → 0.114.1

package/corpus/templates/content/actions/_content-favorites.ts

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+
+import { and, eq, inArray, sql } from "drizzle-orm";
+
+import { schema } from "../server/db/index.js";
+import { normalizeContentSpaceEmail } from "./_content-space-access.js";
+import {
+  personalContentSpaceId,
+  systemIdsForContentSpace,
+} from "./_content-spaces.js";
+
+type Db = any;
+
+export function favoritesSystemIds(userEmail: string) {
+  return systemIdsForContentSpace(
+    personalContentSpaceId(normalizeContentSpaceEmail(userEmail)),
+    "favorites",
+  );
+}
+
+export async function favoriteDocumentIds(
+  db: Db,
+  userEmail: string,
+  documentIds: string[],
+) {
+  if (documentIds.length === 0) return new Set<string>();
+  const favoritesDatabaseId = favoritesSystemIds(userEmail).databaseId;
+  const rows = await db
+    .select({ documentId: schema.contentDatabaseItems.documentId })
+    .from(schema.contentDatabaseItems)
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, favoritesDatabaseId),
+        inArray(schema.contentDatabaseItems.documentId, documentIds),
+      ),
+    );
+  return new Set(rows.map((row: { documentId: string }) => row.documentId));
+}
+
+export async function setFavoriteMembership(args: {
+  db: Db;
+  userEmail: string;
+  documentId: string;
+  favorite: boolean;
+  now: string;
+}) {
+  const email = normalizeContentSpaceEmail(args.userEmail);
+  const favoritesDatabaseId = favoritesSystemIds(email).databaseId;
+  const [existing] = await args.db
+    .select({ id: schema.contentDatabaseItems.id })
+    .from(schema.contentDatabaseItems)
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, favoritesDatabaseId),
+        eq(schema.contentDatabaseItems.documentId, args.documentId),
+      ),
+    );
+
+  if (!args.favorite) {
+    if (existing) {
+      await args.db
+        .delete(schema.contentDatabaseItems)
+        .where(eq(schema.contentDatabaseItems.id, existing.id));
+    }
+    return false;
+  }
+  if (existing) return true;
+
+  const [position] = await args.db
+    .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+    .from(schema.contentDatabaseItems)
+    .where(eq(schema.contentDatabaseItems.databaseId, favoritesDatabaseId));
+  const id = `content_database_item_${createHash("sha256")
+    .update(`${favoritesDatabaseId}:${args.documentId}`)
+    .digest("hex")
+    .slice(0, 32)}`;
+  await args.db
+    .insert(schema.contentDatabaseItems)
+    .values({
+      id,
+      ownerEmail: email,
+      orgId: null,
+      databaseId: favoritesDatabaseId,
+      documentId: args.documentId,
+      position: Number(position?.max ?? -1) + 1,
+      createdAt: args.now,
+      updatedAt: args.now,
+    })
+    .onConflictDoNothing();
+  return true;
+}

package/corpus/templates/content/actions/_content-files.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 
 import { accessFilter } from "@agent-native/core/sharing";
-import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { and, eq, inArray, isNotNull, isNull, or, sql } from "drizzle-orm";
 
 import { schema } from "../server/db/index.js";
 import {
@@ -62,9 +62,44 @@ async function reconcileDocuments(args: {
     args.filesDatabases.map((database) => [database.spaceId, database]),
   );
   const filesDatabaseIds = args.filesDatabases.map((database) => database.id);
-  const filesBackingDocumentIds = new Set(
-    args.filesDatabases.map((database) => database.documentId),
-  );
+  const documentIds = args.documents.map((document) => document.id);
+  const [systemDatabaseDocuments, workspaceReferenceDocuments] =
+    documentIds.length > 0
+      ? await Promise.all([
+          args.db
+            .select({ id: schema.contentDatabases.documentId })
+            .from(schema.contentDatabases)
+            .where(
+              and(
+                inArray(schema.contentDatabases.documentId, documentIds),
+                isNotNull(schema.contentDatabases.systemRole),
+              ),
+            ),
+          args.db
+            .select({ id: schema.contentSpaceCatalogItems.documentId })
+            .from(schema.contentSpaceCatalogItems)
+            .innerJoin(
+              schema.contentDatabases,
+              eq(
+                schema.contentDatabases.id,
+                schema.contentSpaceCatalogItems.catalogDatabaseId,
+              ),
+            )
+            .where(
+              and(
+                inArray(
+                  schema.contentSpaceCatalogItems.documentId,
+                  documentIds,
+                ),
+                eq(schema.contentDatabases.systemRole, "workspaces"),
+              ),
+            ),
+        ])
+      : [[], []];
+  const excludedDocumentIds = new Set([
+    ...systemDatabaseDocuments.map((document: any) => document.id),
+    ...workspaceReferenceDocuments.map((document: any) => document.id),
+  ]);
   const existingItems = filesDatabaseIds.length
     ? await args.db
         .select()
@@ -93,7 +128,7 @@ async function reconcileDocuments(args: {
   const inserts: Array<typeof schema.contentDatabaseItems.$inferInsert> = [];
   for (const document of args.documents) {
     const existing = itemsByDocument.get(document.id) ?? [];
-    if (filesBackingDocumentIds.has(document.id)) {
+    if (excludedDocumentIds.has(document.id)) {
       for (const item of existing) deleteIds.add(item.id);
       continue;
     }
@@ -239,24 +274,23 @@ export async function reconcileContentFilesMemberships(
   const email = normalizeContentSpaceEmail(userEmail);
   const memberships = await listContentOrganizationMemberships(email);
   const personalSpaceId = personalContentSpaceId(email);
-  const orgSpaceIds = new Map<string, string>();
+  const orgSpaces = new Map<
+    string,
+    { spaceId: string; canReconcilePrivateDocuments: boolean }
+  >();
   for (const membership of memberships) {
     const spaceId = organizationContentSpaceId(membership.orgId);
-    try {
-      await resolveContentSpaceAccess(spaceId, "editor");
-      orgSpaceIds.set(membership.orgId, spaceId);
-    } catch (error) {
-      if (
-        error instanceof Error &&
-        error.message ===
-          `Editor access is required for Content space "${spaceId}"`
-      ) {
-        continue;
-      }
-      throw error;
-    }
+    await resolveContentSpaceAccess(spaceId);
+    orgSpaces.set(membership.orgId, {
+      spaceId,
+      canReconcilePrivateDocuments:
+        membership.role === "owner" || membership.role === "admin",
+    });
   }
-  const accessibleSpaceIds = [personalSpaceId, ...orgSpaceIds.values()];
+  const accessibleSpaceIds = [
+    personalSpaceId,
+    ...[...orgSpaces.values()].map(({ spaceId }) => spaceId),
+  ];
   const now = new Date().toISOString();
   const result: ContentFilesReconciliation = {
     assignedSpaces: 0,
@@ -288,7 +322,7 @@ export async function reconcileContentFilesMemberships(
         );
       result.assignedSpaces += personalLegacyDocuments.length;
     }
-    for (const [orgId, spaceId] of orgSpaceIds) {
+    for (const [orgId, orgSpace] of orgSpaces) {
       const legacyDocuments = await tx
         .select({ id: schema.documents.id })
         .from(schema.documents)
@@ -296,12 +330,19 @@ export async function reconcileContentFilesMemberships(
           and(
             eq(schema.documents.orgId, orgId),
             isNull(schema.documents.spaceId),
+            orgSpace.canReconcilePrivateDocuments
+              ? undefined
+              : or(
+                  eq(schema.documents.ownerEmail, email),
+                  eq(schema.documents.visibility, "org"),
+                  eq(schema.documents.visibility, "public"),
+                ),
           ),
         );
       if (!legacyDocuments.length) continue;
       await tx
         .update(schema.documents)
-        .set({ spaceId, updatedAt: now })
+        .set({ spaceId: orgSpace.spaceId, updatedAt: now })
         .where(
           inArray(
             schema.documents.id,
@@ -311,10 +352,25 @@ export async function reconcileContentFilesMemberships(
       result.assignedSpaces += legacyDocuments.length;
     }
 
-    const documents = await tx
+    const accessibleDocuments = await tx
       .select()
       .from(schema.documents)
       .where(inArray(schema.documents.spaceId, accessibleSpaceIds));
+    const orgSpaceById = new Map(
+      [...orgSpaces.values()].map((space) => [space.spaceId, space]),
+    );
+    const documents = accessibleDocuments.filter((document: any) => {
+      if (document.spaceId === personalSpaceId) {
+        return normalizeContentSpaceEmail(document.ownerEmail) === email;
+      }
+      const orgSpace = orgSpaceById.get(document.spaceId);
+      return (
+        orgSpace?.canReconcilePrivateDocuments === true ||
+        normalizeContentSpaceEmail(document.ownerEmail) === email ||
+        document.visibility === "org" ||
+        document.visibility === "public"
+      );
+    });
     const filesDatabases = await tx
       .select()
       .from(schema.contentDatabases)

package/corpus/templates/content/actions/_content-sidebar-state.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+export const CONTENT_SIDEBAR_STATE_VERSION = 1;
+export const CONTENT_SIDEBAR_STATE_SETTING_KEY = "content-sidebar-state";
+
+const expandedIdSchema = z.string().min(1).max(256);
+
+export const contentSidebarStateSchema = z.object({
+  version: z.literal(CONTENT_SIDEBAR_STATE_VERSION),
+  expandedWorkspaceIds: z.array(expandedIdSchema).max(1_000),
+  expandedDocumentIds: z.array(expandedIdSchema).max(5_000),
+});
+
+export type ContentSidebarState = z.infer<typeof contentSidebarStateSchema>;
+
+export function normalizeContentSidebarState(value: unknown) {
+  const parsed = contentSidebarStateSchema.safeParse(value);
+  if (!parsed.success) return null;
+  return {
+    ...parsed.data,
+    expandedWorkspaceIds: [...new Set(parsed.data.expandedWorkspaceIds)],
+    expandedDocumentIds: [...new Set(parsed.data.expandedDocumentIds)],
+  };
+}

package/corpus/templates/content/actions/_content-space-access.ts

@@ -1,25 +1,9 @@
 import { getDbExec } from "@agent-native/core/db";
-import { table, text } from "@agent-native/core/db/schema";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { and, eq, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../server/db/index.js";
 
-// Keep these lightweight table references local. Importing the public org
-// barrel also initializes auth's long-lived cleanup timer, which breaks test
-// suites that intentionally drain fake timers.
-const organizations = table("organizations", {
-  id: text("id").primaryKey(),
-  name: text("name").notNull(),
-  createdBy: text("created_by").notNull(),
-});
-
-const orgMembers = table("org_members", {
-  orgId: text("org_id").notNull(),
-  email: text("email").notNull(),
-  role: text("role").notNull(),
-});
-
 export type ContentSpaceRole = "viewer" | "editor" | "owner";
 
 export type ContentSpaceAccess = {
@@ -40,6 +24,10 @@ export async function getContentOrganizationMembership(
   options: { db?: any } = {},
 ): Promise<{ role: string; name: string; createdBy: string } | null> {
   if (options.db) {
+    // The canonical tables carry the active database dialect. Loading them only
+    // for transaction-scoped checks avoids initializing auth timers elsewhere.
+    const { organizations, orgMembers } =
+      await import("@agent-native/core/org");
     const [row] = await options.db
       .select({
         role: orgMembers.role,
@@ -130,7 +118,7 @@ export async function listContentOrganizationMemberships(userEmail: string) {
 
 export async function resolveContentSpaceAccess(
   spaceId: string,
-  requiredRole: "viewer" | "editor" = "viewer",
+  requiredRole: "viewer" | "contributor" | "editor" = "viewer",
   options: { db?: any } = {},
 ): Promise<ContentSpaceAccess> {
   const userEmail = getRequestUserEmail();
@@ -167,6 +155,16 @@ export async function resolveContentSpaceAccess(
       : membership.role === "admin"
         ? "editor"
         : "viewer";
+  if (
+    requiredRole === "contributor" &&
+    membership.role !== "owner" &&
+    membership.role !== "admin" &&
+    membership.role !== "member"
+  ) {
+    throw new Error(
+      `Contributor access is required for Content space "${spaceId}"`,
+    );
+  }
   if (requiredRole === "editor" && role === "viewer") {
     throw new Error(`Editor access is required for Content space "${spaceId}"`);
   }

package/corpus/templates/content/actions/_content-space-catalog-guards.ts

@@ -0,0 +1,20 @@
+import { inArray } from "drizzle-orm";
+
+import { schema } from "../server/db/index.js";
+
+type Db = any;
+
+export async function assertNotWorkspaceCatalogDocuments(
+  db: Db,
+  documentIds: string[],
+  operation: string,
+) {
+  if (documentIds.length === 0) return;
+  const [workspaceReference] = await db
+    .select({ id: schema.contentSpaceCatalogItems.id })
+    .from(schema.contentSpaceCatalogItems)
+    .where(inArray(schema.contentSpaceCatalogItems.documentId, documentIds));
+  if (workspaceReference) {
+    throw new Error(`Workspace references cannot be ${operation} as pages`);
+  }
+}