@jant/core 0.6.14 → 0.6.15

package/src/services/navigation.ts

@@ -5,7 +5,7 @@
  * with fractional indexing for efficient reordering.
  */
 
-import { and, eq, asc, sql, inArray } from "drizzle-orm";
+import { and, eq, asc, desc, isNull, sql, inArray } from "drizzle-orm";
 import { generateKeyBetween } from "fractional-indexing";
 import type { Database } from "../db/index.js";
 import {
@@ -21,7 +21,10 @@ import {
   stripSitePathPrefix,
   toSameSitePath,
 } from "../lib/url.js";
-import { COLLECTION_FRESHNESS_WINDOW_SECONDS } from "../types.js";
+import {
+  COLLECTION_FRESHNESS_WINDOW_SECONDS,
+  DEFAULT_NAVIGATION_PROFILE,
+} from "../types.js";
 import type {
   NavItem,
   NavItemType,
@@ -30,6 +33,7 @@ import type {
   UpdateNavItem,
   SystemNavKey,
   SuggestedNavLink,
+  NavigationPageCandidate,
 } from "../types.js";
 import { SYSTEM_NAV_KEYS } from "../types.js";
 
@@ -49,11 +53,18 @@ import { isUniqueConstraintError } from "../db/dialect.js";
 
 export interface NavItemService {
   list(): Promise<NavItem[]>;
+  listPageCandidates(options?: {
+    query?: string;
+    limit?: number;
+  }): Promise<NavigationPageCandidate[]>;
   getById(id: string): Promise<NavItem | null>;
   create(data: CreateNavItem): Promise<NavItem>;
-  ensureSystemDefaults(
-    systemKeys?: readonly SystemNavKey[],
-  ): Promise<NavItem[]>;
+  /**
+   * Add missing items from the current default profile without changing
+   * existing navigation state. Call only during provisioning or incomplete
+   * onboarding recovery.
+   */
+  materializeDefaultNavigation(): Promise<NavItem[]>;
   update(id: string, data: UpdateNavItem): Promise<NavItem | null>;
   delete(id: string): Promise<boolean>;
   move(
@@ -72,18 +83,9 @@ export function createNavItemService(
   siteId: string,
   databaseSchema: DatabaseSchema = sqliteSchemaBundle,
 ): NavItemService {
-  const { navItems, postCollections, posts, pathRegistry, collections } =
+  const { navItems, threadCollections, posts, pathRegistry, collections } =
     databaseSchema;
 
-  const defaultSystemOrder = [
-    "latest",
-    "featured",
-    "collections",
-    "archive",
-    "rss",
-    "settings",
-  ] as const satisfies readonly SystemNavKey[];
-
   function toNavItem(row: typeof navItems.$inferSelect): NavItem {
     return {
       id: row.id,
@@ -91,6 +93,7 @@ export function createNavItemService(
       type: row.type as NavItemType,
       systemKey: (row.systemKey as SystemNavKey | null) ?? undefined,
       collectionId: row.collectionId ?? undefined,
+      postId: row.postId ?? undefined,
       label: row.label,
       url: row.url,
       placement: (row.placement ?? "header") as NavItemPlacement,
@@ -100,7 +103,7 @@ export function createNavItemService(
     };
   }
 
-  function normalizeCreateData(data: CreateNavItem) {
+  async function normalizeCreateData(data: CreateNavItem) {
     if (data.type === "system") {
       const config = SYSTEM_NAV_KEYS[data.systemKey];
       if (!config) {
@@ -111,6 +114,7 @@ export function createNavItemService(
         type: data.type,
         systemKey: data.systemKey,
         collectionId: null,
+        postId: null,
         label: "",
         url: config.url,
         placement: data.placement ?? config.defaultPlacement,
@@ -123,6 +127,7 @@ export function createNavItemService(
         type: data.type,
         systemKey: null,
         collectionId: data.collectionId,
+        postId: null,
         label: data.label,
         url: data.url,
         placement: data.placement ?? "header",
@@ -130,10 +135,57 @@ export function createNavItemService(
       };
     }
 
+    if (data.type === "page") {
+      const rows = await db
+        .select({
+          title: posts.title,
+          slug: pathRegistry.path,
+        })
+        .from(posts)
+        .innerJoin(
+          pathRegistry,
+          and(
+            eq(pathRegistry.siteId, siteId),
+            eq(pathRegistry.postId, posts.id),
+            eq(pathRegistry.kind, "slug"),
+          ),
+        )
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            eq(posts.id, data.postId),
+            eq(posts.format, "note"),
+            eq(posts.status, "published"),
+            sql`${posts.visibility} != 'private'`,
+            isNull(posts.replyToId),
+            sql`trim(${posts.title}) != ''`,
+          ),
+        )
+        .limit(1);
+      const page = rows[0];
+      if (!page?.title) {
+        throw new ValidationError(
+          "Page must be a published, non-private titled note",
+        );
+      }
+
+      return {
+        type: data.type,
+        systemKey: null,
+        collectionId: null,
+        postId: data.postId,
+        label: (data.label?.trim() || page.title.trim()).slice(0, 100),
+        url: withLeadingSlash(page.slug),
+        placement: data.placement ?? "header",
+        position: data.position,
+      };
+    }
+
     return {
       type: data.type,
       systemKey: null,
       collectionId: null,
+      postId: null,
       label: data.label,
       url: data.url,
       placement: data.placement ?? "header",
@@ -256,6 +308,63 @@ export function createNavItemService(
       return rows.map(toNavItem);
     },
 
+    async listPageCandidates(options = {}) {
+      const query = options.query?.trim() ?? "";
+      const limit = Math.min(Math.max(Math.trunc(options.limit ?? 20), 1), 50);
+      const escapedQuery = query.replace(/[\\%_]/g, "\\$&");
+      const conditions = [
+        eq(posts.siteId, siteId),
+        eq(posts.format, "note"),
+        eq(posts.status, "published"),
+        sql`${posts.visibility} != 'private'`,
+        isNull(posts.replyToId),
+        sql`trim(${posts.title}) != ''`,
+        isNull(navItems.id),
+      ];
+      if (query) {
+        conditions.push(
+          sql`lower(${posts.title}) LIKE lower(${`%${escapedQuery}%`}) ESCAPE '\\'`,
+        );
+      }
+
+      const rows = await db
+        .select({
+          id: posts.id,
+          title: posts.title,
+          slug: pathRegistry.path,
+          updatedAt: posts.updatedAt,
+        })
+        .from(posts)
+        .innerJoin(
+          pathRegistry,
+          and(
+            eq(pathRegistry.siteId, siteId),
+            eq(pathRegistry.postId, posts.id),
+            eq(pathRegistry.kind, "slug"),
+          ),
+        )
+        .leftJoin(
+          navItems,
+          and(eq(navItems.siteId, siteId), eq(navItems.postId, posts.id)),
+        )
+        .where(and(...conditions))
+        .orderBy(desc(posts.updatedAt), desc(posts.id))
+        .limit(limit);
+
+      return rows.flatMap((row) =>
+        row.title
+          ? [
+              {
+                id: row.id,
+                title: row.title,
+                slug: row.slug,
+                updatedAt: row.updatedAt,
+              },
+            ]
+          : [],
+      );
+    },
+
     async getById(id) {
       const result = await db
         .select()
@@ -268,7 +377,7 @@ export function createNavItemService(
     async create(data) {
       const id = createEntityId("navItem");
       const timestamp = now();
-      const normalized = normalizeCreateData(data);
+      const normalized = await normalizeCreateData(data);
 
       if (normalized.systemKey) {
         const existingSystemItem = await db
@@ -304,6 +413,23 @@ export function createNavItemService(
         }
       }
 
+      if (normalized.postId) {
+        const existingPageItem = await db
+          .select({ id: navItems.id })
+          .from(navItems)
+          .where(
+            and(
+              eq(navItems.siteId, siteId),
+              eq(navItems.postId, normalized.postId),
+            ),
+          )
+          .limit(1);
+
+        if (existingPageItem[0]) {
+          throw new ValidationError("Page already added to navigation");
+        }
+      }
+
       if (normalized.position !== undefined) {
         const result = await db
           .insert(navItems)
@@ -313,6 +439,7 @@ export function createNavItemService(
             type: normalized.type,
             systemKey: normalized.systemKey,
             collectionId: normalized.collectionId,
+            postId: normalized.postId,
             label: normalized.label,
             url: normalized.url,
             placement: normalized.placement,
@@ -336,6 +463,7 @@ export function createNavItemService(
               type: normalized.type,
               systemKey: normalized.systemKey,
               collectionId: normalized.collectionId,
+              postId: normalized.postId,
               label: normalized.label,
               url: normalized.url,
               placement: normalized.placement,
@@ -360,7 +488,7 @@ export function createNavItemService(
       throw new Error("Failed to assign a unique nav item position");
     },
 
-    async ensureSystemDefaults(systemKeys = defaultSystemOrder) {
+    async materializeDefaultNavigation() {
       const existingRows = await db
         .select({ systemKey: navItems.systemKey })
         .from(navItems)
@@ -377,7 +505,7 @@ export function createNavItemService(
       );
 
       const created: NavItem[] = [];
-      for (const systemKey of systemKeys) {
+      for (const systemKey of DEFAULT_NAVIGATION_PROFILE.systemKeys) {
         if (existing.has(systemKey)) continue;
         try {
           created.push(
@@ -408,12 +536,18 @@ export function createNavItemService(
         .limit(1);
       if (!existing[0]) return null;
 
-      if (existing[0].type === "system" || existing[0].type === "collection") {
+      if (
+        existing[0].type === "system" ||
+        existing[0].type === "collection" ||
+        existing[0].type === "page"
+      ) {
         if (data.url !== undefined) {
           throw new ValidationError(
             existing[0].type === "system"
               ? "Built-in navigation URLs are managed automatically"
-              : "Collection navigation URLs are managed automatically",
+              : existing[0].type === "collection"
+                ? "Collection navigation URLs are managed automatically"
+                : "Page navigation URLs are managed automatically",
           );
         }
       }
@@ -528,9 +662,12 @@ export function createNavItemService(
         if (record.postId) {
           const postRows = await db
             .select({
+              id: posts.id,
+              format: posts.format,
               title: posts.title,
               status: posts.status,
               visibility: posts.visibility,
+              replyToId: posts.replyToId,
             })
             .from(posts)
             .where(and(eq(posts.siteId, siteId), eq(posts.id, record.postId)))
@@ -538,8 +675,11 @@ export function createNavItemService(
           const post = postRows[0];
           if (
             !post ||
+            post.format !== "note" ||
             post.status !== "published" ||
-            post.visibility === "private"
+            post.visibility === "private" ||
+            post.replyToId !== null ||
+            !post.title?.trim()
           ) {
             continue;
           }
@@ -549,7 +689,8 @@ export function createNavItemService(
             label: normalizeSuggestedLabel(post.title, candidate.label),
             url: path,
             targetType: "page",
-            navItemType: "link",
+            navItemType: "page",
+            postId: post.id,
           });
           continue;
         }
@@ -603,47 +744,45 @@ export function createNavItemService(
       if (collectionIds.length === 0) return new Map<string, number>();
 
       const threshold = now() - COLLECTION_FRESHNESS_WINDOW_SECONDS;
-
-      // Find collections with recent activity and the latest update timestamp.
-      // 1. A post was added to the collection within the freshness window
-      // 2. A post in the collection was edited within the freshness window
-      // 3. A thread reply was published where the thread root is in the collection
+      const threadActivityAt = sql<number>`CASE
+        WHEN ${posts.updatedAt} > ${posts.createdAt}
+          AND ${posts.updatedAt} > COALESCE(${posts.lastActivityAt}, -1)
+        THEN ${posts.updatedAt}
+        ELSE COALESCE(${posts.lastActivityAt}, ${posts.updatedAt})
+      END`;
+
+      // Find collections with recent Thread activity and its latest timestamp.
+      // `lastActivityAt` is maintained on the root when a non-quiet reply is
+      // published. A later `updatedAt` keeps actual root edits visible without
+      // treating a freshly imported historical root as newly active.
       const rows = await db
         .select({
-          collectionId: postCollections.collectionId,
+          collectionId: threadCollections.collectionId,
           latestAt:
-            sql<number>`MAX(CASE WHEN ${postCollections.createdAt} > ${posts.updatedAt} THEN ${postCollections.createdAt} ELSE ${posts.updatedAt} END)`.as(
+            sql<number>`MAX(CASE WHEN ${threadCollections.createdAt} > ${threadActivityAt} THEN ${threadCollections.createdAt} ELSE ${threadActivityAt} END)`.as(
               "latest_at",
             ),
         })
-        .from(postCollections)
+        .from(threadCollections)
         .innerJoin(
           posts,
           and(
-            eq(posts.id, postCollections.postId),
-            eq(posts.siteId, postCollections.siteId),
+            eq(posts.id, threadCollections.threadId),
+            eq(posts.siteId, threadCollections.siteId),
           ),
         )
         .where(
           and(
-            eq(postCollections.siteId, siteId),
-            inArray(postCollections.collectionId, collectionIds),
+            eq(threadCollections.siteId, siteId),
+            inArray(threadCollections.collectionId, collectionIds),
             sql`(
-              ${postCollections.createdAt} > ${threshold}
-              OR (${posts.updatedAt} > ${threshold}
+              ${threadCollections.createdAt} > ${threshold}
+              OR (${threadActivityAt} > ${threshold}
                 AND ${posts.status} = 'published')
-              OR EXISTS (
-                SELECT 1 FROM ${posts} reply
-                WHERE reply.site_id = ${postCollections.siteId}
-                  AND reply.thread_id = ${postCollections.postId}
-                  AND reply.reply_to_id IS NOT NULL
-                  AND reply.status = 'published'
-                  AND reply.created_at > ${threshold}
-              )
             )`,
           ),
         )
-        .groupBy(postCollections.collectionId);
+        .groupBy(threadCollections.collectionId);
 
       return new Map(rows.map((r) => [r.collectionId, r.latestAt]));
     },