@jant/core 0.3.35 → 0.3.37

package/src/routes/pages/collection.tsx

@@ -10,8 +10,8 @@ import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import {
   createMediaContext,
-  toPostViewsFromPosts,
   toPostViews,
+  loadThreadRootPermalinks,
 } from "../../lib/view.js";
 import { defaultRssRenderer } from "../../lib/feed.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
@@ -27,35 +27,63 @@ collectionRoutes.get("/:slug", async (c) => {
   const collection = await c.var.services.collections.getBySlug(slug);
   if (!collection) return c.notFound();
 
-  // Fetch posts and all collections in parallel
-  const [posts, allCollections] = await Promise.all([
+  // Fetch posts, all collections, sidebar items, and post counts in parallel
+  const navData = await getNavigationData(c);
+
+  const [posts, allCollections, sidebarItems, postCounts] = await Promise.all([
     c.var.services.posts.list({
       collectionId: collection.id,
       status: "published",
-      excludeReplies: true,
+      excludePrivate: !navData.isAuthenticated,
     }),
     c.var.services.collections.list(),
+    c.var.services.collections.listSidebarItems(),
+    c.var.services.collections.getPostCounts(),
   ]);
 
-  const navData = await getNavigationData(c);
-
-  // Transform to View Models
+  // Batch-load media and thread root permalinks in parallel
+  const postIds = posts.map((p) => p.id);
+  const [rawMediaMap, rootPermalinkMap] = await Promise.all([
+    c.var.services.media.getByPostIds(postIds),
+    loadThreadRootPermalinks(
+      posts,
+      c.var.services.posts.getById.bind(c.var.services.posts),
+    ),
+  ]);
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const postViews = toPostViewsFromPosts(posts, mediaCtx);
+  const mediaMap = buildMediaMap(
+    rawMediaMap,
+    mediaCtx.r2PublicUrl,
+    mediaCtx.imageTransformUrl,
+    mediaCtx.s3PublicUrl,
+  );
+
+  const postViews = toPostViews(
+    posts.map((p) => ({
+      ...p,
+      mediaAttachments: mediaMap.get(p.id) ?? [],
+    })),
+    mediaCtx,
+    rootPermalinkMap,
+  );
+
+  const items = postViews.map((post) => ({ post }));
 
   return renderPublicPage(c, {
     title: `${collection.title} - ${navData.siteName}`,
     description: collection.description ?? undefined,
     navData,
     sidebar: (
-      <CollectionsSidebar collections={allCollections} activeSlug={slug} />
+      <CollectionsSidebar
+        collections={allCollections}
+        sidebarItems={sidebarItems}
+        activeSlug={slug}
+        isAuthenticated={navData.isAuthenticated}
+        postCounts={postCounts}
+      />
     ),
     content: (
-      <CollectionPage
-        collection={collection}
-        posts={postViews}
-        hasMore={false}
-      />
+      <CollectionPage collection={collection} items={items} hasMore={false} />
     ),
   });
 });
@@ -77,6 +105,7 @@ collectionRoutes.get("/:slug/feed", async (c) => {
     collectionId: collection.id,
     status: "published",
     excludeReplies: true,
+    excludePrivate: true,
     limit: feedLimit,
   });
 

package/src/routes/pages/collections.tsx

@@ -17,8 +17,9 @@ type Env = { Bindings: Bindings; Variables: AppVariables };
 export const collectionsPageRoutes = new Hono<Env>();
 
 collectionsPageRoutes.get("/", async (c) => {
-  const [allCollections, postCounts] = await Promise.all([
+  const [allCollections, sidebarItems, postCounts] = await Promise.all([
     c.var.services.collections.list(),
+    c.var.services.collections.listSidebarItems(),
     c.var.services.collections.getPostCounts(),
   ]);
 
@@ -32,7 +33,15 @@ collectionsPageRoutes.get("/", async (c) => {
   return renderPublicPage(c, {
     title: `Collections - ${navData.siteName}`,
     navData,
-    sidebar: <CollectionsSidebar collections={allCollections} />,
+    sidebar: (
+      <CollectionsSidebar
+        collections={allCollections}
+        sidebarItems={sidebarItems}
+        activeSlug={undefined}
+        isAuthenticated={navData.isAuthenticated}
+        postCounts={postCounts}
+      />
+    ),
     content: <CollectionsPage collections={collections} />,
   });
 });

package/src/routes/pages/featured.tsx

@@ -9,7 +9,11 @@ import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
-import { createMediaContext, toPostViewsFromPosts } from "../../lib/view.js";
+import {
+  createMediaContext,
+  toPostViewsFromPosts,
+  loadThreadRootPermalinks,
+} from "../../lib/view.js";
 import { FeaturedPage } from "../../ui/pages/FeaturedPage.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
@@ -27,11 +31,31 @@ featuredRoutes.get("/", async (c) => {
   const posts = await c.var.services.posts.list({
     featured: true,
     status: "published",
-    excludeReplies: true,
+    excludePrivate: !navData.isAuthenticated,
   });
 
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const postViews = toPostViewsFromPosts(posts, mediaCtx);
+
+  const rootPermalinkMap = await loadThreadRootPermalinks(
+    posts,
+    c.var.services.posts.getById.bind(c.var.services.posts),
+  );
+
+  // Determine which posts are last in their thread for reply button visibility
+  const threadIds = [...new Set(posts.map((p) => p.threadId))];
+  const lastPostMap =
+    await c.var.services.posts.getLastPostIdsByThread(threadIds);
+  const isLastInThreadMap = new Map<string, boolean>();
+  for (const p of posts) {
+    isLastInThreadMap.set(p.id, lastPostMap.get(p.threadId) === p.id);
+  }
+
+  const postViews = toPostViewsFromPosts(
+    posts,
+    mediaCtx,
+    rootPermalinkMap,
+    isLastInThreadMap,
+  );
 
   // Convert to timeline items (simple — no thread previews)
   const items = postViews.map((post) => ({ post }));

package/src/routes/pages/home.tsx

@@ -14,7 +14,11 @@ import type { AppVariables } from "../../types/app-context.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { assembleTimeline } from "../../lib/timeline.js";
-import { createMediaContext, toPostViewsFromPosts } from "../../lib/view.js";
+import {
+  createMediaContext,
+  toPostViewsFromPosts,
+  loadThreadRootPermalinks,
+} from "../../lib/view.js";
 import { HomePage } from "../../ui/pages/HomePage.js";
 import { FeaturedPage } from "../../ui/pages/FeaturedPage.js";
 
@@ -30,10 +34,16 @@ homeRoutes.get("/", async (c) => {
     const posts = await c.var.services.posts.list({
       featured: true,
       status: "published",
-      excludeReplies: true,
+      excludePrivate: !navData.isAuthenticated,
     });
     const mediaCtx = createMediaContext(c.var.appConfig);
-    const postViews = toPostViewsFromPosts(posts, mediaCtx);
+
+    const rootPermalinkMap = await loadThreadRootPermalinks(
+      posts,
+      c.var.services.posts.getById.bind(c.var.services.posts),
+    );
+
+    const postViews = toPostViewsFromPosts(posts, mediaCtx, rootPermalinkMap);
     const items = postViews.map((post) => ({ post }));
 
     return renderPublicPage(c, {
@@ -43,30 +53,21 @@ homeRoutes.get("/", async (c) => {
     });
   }
 
-  // Default: show latest posts
+  // Default: show latest posts (pinned posts sort to top via service layer)
   const pageParam = c.req.query("page");
   const page = pageParam ? Math.max(1, parseInt(pageParam, 10) || 1) : 1;
 
   const { items, currentPage, totalPages } = await assembleTimeline(c, {
     page,
+    isAuthenticated: navData.isAuthenticated,
   });
 
-  // Fetch pinned posts
-  const pinnedPosts = await c.var.services.posts.list({
-    pinned: true,
-    status: "published",
-    excludeReplies: true,
-  });
-  const mediaCtx = createMediaContext(c.var.appConfig);
-  const pinnedItems = toPostViewsFromPosts(pinnedPosts, mediaCtx);
-
   return renderPublicPage(c, {
     title: navData.siteName,
     navData,
     content: (
       <HomePage
         items={items}
-        pinnedItems={pinnedItems}
         currentPage={currentPage}
         totalPages={totalPages}
       />

package/src/routes/pages/latest.tsx

@@ -13,7 +13,6 @@ import type { AppVariables } from "../../types/app-context.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { assembleTimeline } from "../../lib/timeline.js";
-import { createMediaContext, toPostViewsFromPosts } from "../../lib/view.js";
 import { HomePage } from "../../ui/pages/HomePage.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
@@ -33,24 +32,15 @@ latestRoutes.get("/", async (c) => {
 
   const { items, currentPage, totalPages } = await assembleTimeline(c, {
     page,
+    isAuthenticated: navData.isAuthenticated,
   });
 
-  // Fetch pinned posts
-  const pinnedPosts = await c.var.services.posts.list({
-    pinned: true,
-    status: "published",
-    excludeReplies: true,
-  });
-  const mediaCtx = createMediaContext(c.var.appConfig);
-  const pinnedItems = toPostViewsFromPosts(pinnedPosts, mediaCtx);
-
   return renderPublicPage(c, {
     title: `Latest - ${navData.siteName}`,
     navData,
     content: (
       <HomePage
         items={items}
-        pinnedItems={pinnedItems}
         currentPage={currentPage}
         totalPages={totalPages}
       />

package/src/routes/pages/new.tsx

@@ -0,0 +1,39 @@
+import { Hono } from "hono";
+import { msg } from "@lingui/core/macro";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../types/app-context.js";
+import { requireAuth } from "../../middleware/auth.js";
+import { getNavigationData } from "../../lib/navigation.js";
+import { renderPublicPage } from "../../lib/render.js";
+import { getI18n } from "../../i18n/index.js";
+import { ComposePage } from "../../ui/pages/ComposePage.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const newPostRoutes = new Hono<Env>();
+
+newPostRoutes.use("/new", requireAuth());
+
+newPostRoutes.get("/new", async (c) => {
+  const navData = await getNavigationData(c);
+  const i18n = getI18n(c);
+
+  return renderPublicPage(c, {
+    title: `${i18n._(
+      msg({
+        message: "New post",
+        comment: "@context: Browser page title for the new post page",
+      }),
+    )} - ${navData.siteName}`,
+    navData,
+    showComposeDialog: false,
+    showHeader: false,
+    content: (
+      <ComposePage
+        collections={navData.collections}
+        uploadMaxFileSize={c.var.appConfig.uploadMaxFileSize}
+        closeHref="/"
+      />
+    ),
+  });
+});

package/src/routes/pages/page.tsx

@@ -1,80 +1,126 @@
 /**
- * Custom Page Route
+ * Catch-all Route
  *
- * Serves pages and posts with custom paths via the path registry.
- * This is a catch-all route mounted at "/" - must be registered last.
- * The path registry eliminates ambiguity: each path maps to exactly
- * one entity (page, post, or redirect).
+ * Resolves post slugs, aliases, redirects, and collection aliases.
+ * Must be registered last.
  */
 
-import { Hono } from "hono";
+import { Hono, type Context } from "hono";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
-import { SinglePage } from "../../ui/pages/SinglePage.js";
 import { PostPage } from "../../ui/pages/PostPage.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
-import { createMediaContext, toPageView, toPostView } from "../../lib/view.js";
+import { createMediaContext, toPostView } from "../../lib/view.js";
+import type { Post } from "../../types.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const pageRoutes = new Hono<Env>();
 
-// Catch-all for custom page slugs and post paths (including multi-level)
+async function renderPost(c: Context<Env>, post: Post) {
+  const mediaCtx = createMediaContext(c.var.appConfig);
+
+  // Load the full thread if this post is part of one
+  const threadRootId = post.threadId;
+  const threadPosts = (
+    await c.var.services.posts.getThread(threadRootId)
+  ).filter((threadPost) => threadPost.status === "published");
+
+  // Batch load media for all thread posts (or just this post if solo)
+  const allPostIds =
+    threadPosts.length > 1 ? threadPosts.map((p) => p.id) : [post.id];
+  const rawMediaMap = await c.var.services.media.getByPostIds(allPostIds);
+  const mediaMap = buildMediaMap(
+    rawMediaMap,
+    mediaCtx.r2PublicUrl,
+    mediaCtx.imageTransformUrl,
+    mediaCtx.s3PublicUrl,
+  );
+
+  // Batch load collections for all posts
+  const collectionsMap =
+    await c.var.services.collections.getCollectionsByPostIds(allPostIds);
+
+  const postView = toPostView(
+    { ...post, mediaAttachments: mediaMap.get(post.id) ?? [] },
+    mediaCtx,
+    collectionsMap.get(post.id),
+  );
+
+  // Build thread post views if this is a multi-post thread
+  const threadPostViews =
+    threadPosts.length > 1
+      ? threadPosts.map((tp, i) =>
+          toPostView(
+            { ...tp, mediaAttachments: mediaMap.get(tp.id) ?? [] },
+            mediaCtx,
+            collectionsMap.get(tp.id),
+            undefined,
+            i === threadPosts.length - 1,
+          ),
+        )
+      : undefined;
+
+  const navData = await getNavigationData(c);
+  const title = post.title || navData.siteName;
+
+  return renderPublicPage(c, {
+    title,
+    description: post.body?.slice(0, 160),
+    navData,
+    content: <PostPage post={postView} threadPosts={threadPostViews} />,
+  });
+}
+
+// Catch-all for path-registry backed post URLs, aliases, and redirects
 pageRoutes.get("/*", async (c) => {
   const fullPath = c.req.path.slice(1); // Remove leading /
   if (!fullPath) return c.notFound();
 
-  const entry = await c.var.services.pathRegistry.getByPath(fullPath);
+  const resolved = await c.var.services.paths.resolve(fullPath);
+  if (!resolved) return c.notFound();
 
-  if (entry?.ownerType === "page") {
-    const page = await c.var.services.pages.getById(entry.ownerId);
-    if (!page || page.status === "draft") {
-      return c.notFound();
-    }
+  if (resolved.kind === "redirect" && resolved.redirectToPath) {
+    return c.redirect(
+      `/${resolved.redirectToPath}`,
+      resolved.redirectType ?? 301,
+    );
+  }
 
-    const navData = await getNavigationData(c);
-    const pageView = toPageView(page);
+  if (resolved.postId) {
+    const post = await c.var.services.posts.getById(resolved.postId);
+    if (!post || post.status === "draft") return c.notFound();
 
-    return renderPublicPage(c, {
-      title: `${page.title || fullPath} - ${navData.siteName}`,
-      description: page.body?.slice(0, 160),
-      navData,
-      content: <SinglePage page={pageView} />,
-    });
-  }
+    if (post.visibility === "private") {
+      const navData = await getNavigationData(c);
+      if (!navData.isAuthenticated) return c.notFound();
+    }
 
-  if (entry?.ownerType === "post") {
-    const post = await c.var.services.posts.getById(entry.ownerId);
-    if (!post || post.status === "draft") {
-      return c.notFound();
+    // If accessed via slug but an alias exists, redirect to the alias
+    if (resolved.kind === "slug") {
+      const alias = await c.var.services.customUrls.getByTarget(
+        "post",
+        post.id,
+      );
+      if (alias) {
+        return c.redirect(`/${alias.path}`, 301);
+      }
     }
 
-    // Load media attachments
-    const rawMediaMap = await c.var.services.media.getByPostIds([post.id]);
-    const mediaCtx = createMediaContext(c.var.appConfig);
-    const mediaMap = buildMediaMap(
-      rawMediaMap,
-      mediaCtx.r2PublicUrl,
-      mediaCtx.imageTransformUrl,
-      mediaCtx.s3PublicUrl,
-    );
+    return renderPost(c, post);
+  }
 
-    const postView = toPostView(
-      { ...post, mediaAttachments: mediaMap.get(post.id) ?? [] },
-      mediaCtx,
+  if (resolved.collectionId) {
+    const collection = await c.var.services.collections.getById(
+      resolved.collectionId,
     );
+    if (!collection) return c.notFound();
 
-    const navData = await getNavigationData(c);
-    const title = post.title || navData.siteName;
-
-    return renderPublicPage(c, {
-      title,
-      description: post.body?.slice(0, 160),
-      navData,
-      content: <PostPage post={postView} />,
-    });
+    if (resolved.kind === "alias") {
+      return c.redirect(`/c/${collection.slug}`, 301);
+    }
   }
 
   return c.notFound();

package/src/routes/pages/search.tsx

@@ -50,7 +50,7 @@ searchRoutes.get("/", async (c) => {
 
   // Transform to View Models
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const resultViews = toSearchResultViews(results, mediaCtx);
+  const resultViews = toSearchResultViews(results, mediaCtx, query);
 
   return renderPublicPage(c, {
     title: query

package/src/services/__tests__/api-token.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createApiTokenService } from "../api-token.js";
+import type { Database } from "../../db/index.js";
+
+describe("ApiTokenService", () => {
+  let db: Database;
+  let service: ReturnType<typeof createApiTokenService>;
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    db = testDb.db as unknown as Database;
+    service = createApiTokenService(db);
+  });
+
+  describe("create", () => {
+    it("returns a token with jnt_ prefix and metadata", async () => {
+      const { token, plaintext } = await service.create("Test Token");
+
+      expect(plaintext).toMatch(/^jnt_[0-9a-f]{64}$/);
+      expect(token.name).toBe("Test Token");
+      expect(token.prefix).toHaveLength(8);
+      expect(token.lastUsedAt).toBeNull();
+      expect(token.createdAt).toBeGreaterThan(0);
+      expect(token.updatedAt).toBeGreaterThan(0);
+      expect(token.id).toBeTruthy();
+    });
+
+    it("does not expose tokenHash in the returned entity", async () => {
+      const { token } = await service.create("Test");
+
+      expect(token).not.toHaveProperty("tokenHash");
+    });
+
+    it("generates unique tokens each time", async () => {
+      const { plaintext: t1 } = await service.create("Token 1");
+      const { plaintext: t2 } = await service.create("Token 2");
+
+      expect(t1).not.toBe(t2);
+    });
+  });
+
+  describe("list", () => {
+    it("returns empty array when no tokens exist", async () => {
+      const tokens = await service.list();
+      expect(tokens).toEqual([]);
+    });
+
+    it("returns all created tokens", async () => {
+      await service.create("Token A");
+      await service.create("Token B");
+
+      const tokens = await service.list();
+      expect(tokens).toHaveLength(2);
+      expect(tokens[0]?.name).toBe("Token A");
+      expect(tokens[1]?.name).toBe("Token B");
+    });
+
+    it("does not include tokenHash in listed tokens", async () => {
+      await service.create("Token");
+
+      const tokens = await service.list();
+      expect(tokens[0]).not.toHaveProperty("tokenHash");
+    });
+  });
+
+  describe("verify", () => {
+    it("returns token ID for valid token", async () => {
+      const { token, plaintext } = await service.create("Test");
+
+      const result = await service.verify(plaintext);
+      expect(result).toBe(token.id);
+    });
+
+    it("returns null for invalid token", async () => {
+      await service.create("Test");
+
+      const result = await service.verify("jnt_" + "0".repeat(64));
+      expect(result).toBeNull();
+    });
+
+    it("returns null for token without jnt_ prefix", async () => {
+      const result = await service.verify("invalid_token");
+      expect(result).toBeNull();
+    });
+
+    it("returns null for empty string", async () => {
+      const result = await service.verify("");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("delete", () => {
+    it("returns true when token exists", async () => {
+      const { token } = await service.create("Test");
+
+      const result = await service.delete(token.id);
+      expect(result).toBe(true);
+    });
+
+    it("returns false when token does not exist", async () => {
+      const result = await service.delete("nonexistent-id");
+      expect(result).toBe(false);
+    });
+
+    it("prevents verification of deleted token", async () => {
+      const { token, plaintext } = await service.create("Test");
+      await service.delete(token.id);
+
+      const result = await service.verify(plaintext);
+      expect(result).toBeNull();
+    });
+
+    it("removes token from list", async () => {
+      const { token } = await service.create("Test");
+      await service.delete(token.id);
+
+      const tokens = await service.list();
+      expect(tokens).toHaveLength(0);
+    });
+  });
+
+  describe("updateLastUsed", () => {
+    it("updates the lastUsedAt timestamp", async () => {
+      const { token } = await service.create("Test");
+      expect(token.lastUsedAt).toBeNull();
+
+      await service.updateLastUsed(token.id);
+
+      const tokens = await service.list();
+      const updated = tokens.find((t) => t.id === token.id);
+      expect(updated?.lastUsedAt).toBeGreaterThan(0);
+    });
+  });
+});