@jant/core 0.6.14 → 0.6.16

package/src/routes/pages/page.tsx

@@ -5,14 +5,19 @@
  * Must be registered last.
  */
 
+import { msg } from "@lingui/core/macro";
 import { Hono, type Context } from "hono";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
+import { getI18n } from "../../i18n/index.js";
+import { requireAuth } from "../../middleware/auth.js";
 import { PostPage } from "../../ui/pages/PostPage.js";
+import { DraftPreviewBar } from "../../ui/shared/DraftPreviewBar.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { renderPublicPage } from "../../lib/render.js";
 import { buildPageTitle } from "../../lib/page-title.js";
 import { buildPostMeta } from "../../lib/post-meta.js";
+import { isReservedPath } from "../../lib/constants.js";
 import {
   assemblePostPageDisplay,
   type PostPageDisplayData,
@@ -203,7 +208,7 @@ function canRenderDraftAboutEditor(
 async function renderPost(
   c: Context<Env>,
   post: Post,
-  options: { allowDraft?: boolean } = {},
+  options: { allowDraft?: boolean; isPreview?: boolean } = {},
 ) {
   // Start navData fetch immediately — it's independent of thread/media queries
   const navDataPromise = getNavigationData(c);
@@ -211,6 +216,7 @@ async function renderPost(
     // Private-post access is validated before renderPost() is called.
     isAuthenticated: true,
     allowDraft: options.allowDraft,
+    includeDraftThread: options.isPreview,
   });
   if (!display) {
     return c.notFound();
@@ -218,14 +224,51 @@ async function renderPost(
 
   const navData = await navDataPromise;
   const meta = buildPostMeta(post, navData.siteName);
+  const postView =
+    options.isPreview && display.postView.status === "draft"
+      ? {
+          ...display.postView,
+          permalink: toPublicPath(
+            `/preview/${display.postView.slug}`,
+            c.var.appConfig.sitePathPrefix,
+          ),
+        }
+      : display.postView;
+  const threadPostViews = options.isPreview
+    ? display.threadPostViews?.map((threadPost) =>
+        threadPost.status === "draft"
+          ? {
+              ...threadPost,
+              permalink: toPublicPath(
+                `/preview/${threadPost.slug}`,
+                c.var.appConfig.sitePathPrefix,
+              ),
+            }
+          : threadPost,
+      )
+    : display.threadPostViews;
+  const previewTitle = options.isPreview
+    ? getI18n(c)._(
+        msg({
+          message: "Draft preview",
+          comment: "@context: Browser title prefix for a draft preview page",
+        }),
+      )
+    : null;
   const canonicalHref = buildPostCanonicalHref(
     display.postView,
     display.threadPostViews,
     c.var.appConfig.siteUrl,
   );
+  const draftEditHref = `${toPublicPath(
+    `/preview/${post.slug}`,
+    c.var.appConfig.sitePathPrefix,
+  )}?edit=1`;
 
   return renderPublicPage(c, {
-    title: buildPageTitle(meta.title, navData.siteName),
+    title: previewTitle
+      ? buildPageTitle(previewTitle, meta.title, navData.siteName)
+      : buildPageTitle(meta.title, navData.siteName),
     description: meta.description,
     ...(post.status === "published"
       ? {
@@ -247,18 +290,58 @@ async function renderPost(
         }
       : {}),
     navData,
+    ...(options.isPreview
+      ? {
+          pageChrome: <DraftPreviewBar editHref={draftEditHref} />,
+          noindex: true,
+        }
+      : {}),
     content: (
-      <PostPage post={display.postView} threadPosts={display.threadPostViews} />
+      <PostPage
+        post={postView}
+        threadPosts={threadPostViews}
+        isPreview={options.isPreview}
+      />
     ),
   });
 }
 
+pageRoutes.get("/preview/:slug", requireAuth(), async (c) => {
+  const post = await c.var.services.posts.getBySlug(c.req.param("slug"));
+  if (!post) return c.notFound();
+
+  if (post.status === "published") {
+    return c.redirect(
+      toPublicPath(`/${post.slug}`, c.var.appConfig.sitePathPrefix),
+    );
+  }
+
+  c.header("Cache-Control", "private, no-store");
+  c.header("X-Robots-Tag", "noindex, nofollow");
+  return renderPost(c, post, { allowDraft: true, isPreview: true });
+});
+
 // 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 sitePathPrefix = c.var.appConfig.sitePathPrefix;
 
+  // Explicit application routes are registered before this catch-all. Any
+  // unmatched path under a reserved prefix is therefore an application 404,
+  // never a legacy alias or redirect from path_registry.
+  if (isReservedPath(fullPath)) return c.notFound();
+
+  // Stored redirects outrank the normal post/collection/deep-link resolvers,
+  // but can never shadow an explicit or reserved application route.
+  const resolved = await c.var.services.paths.resolve(fullPath);
+  if (resolved?.kind === "redirect" && resolved.redirectToPath) {
+    return c.redirect(
+      toPublicHref(`/${resolved.redirectToPath}`, sitePathPrefix),
+      resolved.redirectType ?? 301,
+    );
+  }
+
   if (fullPath.endsWith("/feed")) {
     const collectionPath = fullPath.slice(0, -"/feed".length);
     if (!collectionPath) return c.notFound();
@@ -360,16 +443,8 @@ pageRoutes.get("/*", async (c) => {
     }
   }
 
-  const resolved = await c.var.services.paths.resolve(fullPath);
   if (!resolved) return c.notFound();
 
-  if (resolved.kind === "redirect" && resolved.redirectToPath) {
-    return c.redirect(
-      toPublicHref(`/${resolved.redirectToPath}`, sitePathPrefix),
-      resolved.redirectType ?? 301,
-    );
-  }
-
   if (resolved.kind === "archive" && resolved.archiveQuery) {
     const overrides = Object.fromEntries(
       new URLSearchParams(resolved.archiveQuery),

package/src/routes/site-skill.ts

@@ -0,0 +1,18 @@
+import { Hono } from "hono";
+import { renderSiteSkill } from "../lib/site-skill.js";
+import type { Bindings } from "../types.js";
+import type { AppVariables } from "../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const siteSkillRoutes = new Hono<Env>();
+
+siteSkillRoutes.get("/skill.md", (c) => {
+  return new Response(renderSiteSkill(c.var.appConfig.siteUrl), {
+    headers: {
+      "Cache-Control": "public, max-age=300, s-maxage=3600",
+      "Content-Type": "text/markdown; charset=utf-8",
+      "X-Robots-Tag": "noindex",
+    },
+  });
+});

package/src/services/__tests__/auth.test.ts

@@ -11,7 +11,7 @@ import {
   media,
   navItems,
   pathRegistry,
-  postCollections,
+  threadCollections,
   posts,
   session,
   settings as settingsTable,
@@ -165,9 +165,9 @@ describe("AuthService", () => {
       updatedAt: timestamp,
     });
 
-    await db.insert(postCollections).values({
+    await db.insert(threadCollections).values({
       siteId: DEFAULT_TEST_SITE_ID,
-      postId: "pst_01km9authdelete00000000000",
+      threadId: "pst_01km9authdelete00000000000",
       collectionId: "col_01km9authdelete00000000000",
       createdAt: timestamp,
     });
@@ -245,7 +245,9 @@ describe("AuthService", () => {
       const remainingDirectoryItems = await db
         .select()
         .from(collectionDirectoryItems);
-      const remainingPostCollections = await db.select().from(postCollections);
+      const remainingThreadCollections = await db
+        .select()
+        .from(threadCollections);
       const remainingNavItems = await db.select().from(navItems);
       const remainingApiTokens = await db.select().from(apiTokens);
       const existingSites = await db.select().from(sites);
@@ -262,7 +264,7 @@ describe("AuthService", () => {
       expect(remainingCollections).toHaveLength(0);
       expect(remainingPaths).toHaveLength(0);
       expect(remainingDirectoryItems).toHaveLength(0);
-      expect(remainingPostCollections).toHaveLength(0);
+      expect(remainingThreadCollections).toHaveLength(0);
       expect(remainingNavItems).toHaveLength(0);
       expect(remainingApiTokens).toHaveLength(0);
       expect(existingSites).toHaveLength(0);

package/src/services/__tests__/collection.test.ts

@@ -281,7 +281,7 @@ describe("CollectionService", () => {
         format: "note",
         bodyMarkdown: "Book note",
       });
-      await collectionService.addPost(reading.id, post.id);
+      await collectionService.addThread(reading.id, post.id);
 
       const directory = await collectionService.listDirectoryData();
 
@@ -297,7 +297,7 @@ describe("CollectionService", () => {
           type: "collection",
           collection: expect.objectContaining({
             id: reading.id,
-            postCount: 1,
+            threadCount: 1,
             recentActivityAt: post.lastActivityAt,
           }),
         }),
@@ -309,6 +309,61 @@ describe("CollectionService", () => {
       ]);
     });
 
+    // The directory's "recent activity" uses the same definition as every
+    // other surface: the Thread gained a post. Editing one is not activity,
+    // or fixing a typo would reshuffle the whole collection directory.
+    it("does not treat a later Root edit as recent activity", async () => {
+      vi.useFakeTimers();
+      try {
+        vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+        const collection = await collectionService.create({
+          slug: "edited-thread",
+          title: "Edited Thread",
+        });
+        const root = await postService.create({
+          format: "note",
+          bodyMarkdown: "before",
+        });
+        await collectionService.addThread(collection.id, root.id);
+
+        vi.setSystemTime(new Date("2024-01-01T00:01:00Z"));
+        await postService.update(root.id, { bodyMarkdown: "after" });
+
+        const directory = await collectionService.listDirectoryData();
+        expect(directory.collections[0]?.recentActivityAt).toBe(1704067200);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("treats a new reply as recent activity", async () => {
+      vi.useFakeTimers();
+      try {
+        vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+        const collection = await collectionService.create({
+          slug: "growing-thread",
+          title: "Growing Thread",
+        });
+        const root = await postService.create({
+          format: "note",
+          bodyMarkdown: "root",
+        });
+        await collectionService.addThread(collection.id, root.id);
+
+        vi.setSystemTime(new Date("2024-01-01T00:01:00Z"));
+        await postService.create({
+          format: "note",
+          bodyMarkdown: "reply",
+          replyToId: root.id,
+        });
+
+        const directory = await collectionService.listDirectoryData();
+        expect(directory.collections[0]?.recentActivityAt).toBe(1704067260);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it("includes custom links in directory items", async () => {
       const link = await collectionService.createDirectoryItem({
         type: "link",
@@ -451,7 +506,7 @@ describe("CollectionService", () => {
         bodyMarkdown: "test post",
       });
 
-      await collectionService.addPost(collection.id, post.id);
+      await collectionService.addThread(collection.id, post.id);
 
       // Verify association exists
       const before = await collectionService.getCollectionsByPostId(post.id);
@@ -736,15 +791,15 @@ describe("CollectionService", () => {
     });
   });
 
-  describe("getPostCounts", () => {
+  describe("getThreadCounts", () => {
     it("returns empty map when no posts exist", async () => {
       await collectionService.create({ slug: "empty", title: "Empty" });
 
-      const counts = await collectionService.getPostCounts();
+      const counts = await collectionService.getThreadCounts();
       expect(counts.size).toBe(0);
     });
 
-    it("returns correct counts for collections with posts", async () => {
+    it("returns correct counts for collections with Threads", async () => {
       const col1 = await collectionService.create({
         slug: "col1",
         title: "Col 1",
@@ -767,16 +822,16 @@ describe("CollectionService", () => {
         bodyMarkdown: "post 3",
       });
 
-      await collectionService.addPost(col1.id, p1.id);
-      await collectionService.addPost(col1.id, p2.id);
-      await collectionService.addPost(col2.id, p3.id);
+      await collectionService.addThread(col1.id, p1.id);
+      await collectionService.addThread(col1.id, p2.id);
+      await collectionService.addThread(col2.id, p3.id);
 
-      const counts = await collectionService.getPostCounts();
+      const counts = await collectionService.getThreadCounts();
       expect(counts.get(col1.id)).toBe(2);
       expect(counts.get(col2.id)).toBe(1);
     });
 
-    it("does not count posts without a collection", async () => {
+    it("does not count Threads without a collection", async () => {
       const col = await collectionService.create({
         slug: "col",
         title: "Col",
@@ -791,14 +846,14 @@ describe("CollectionService", () => {
         bodyMarkdown: "no collection",
       });
 
-      await collectionService.addPost(col.id, p1.id);
+      await collectionService.addThread(col.id, p1.id);
 
-      const counts = await collectionService.getPostCounts();
+      const counts = await collectionService.getThreadCounts();
       expect(counts.get(col.id)).toBe(1);
       expect(counts.size).toBe(1);
     });
 
-    it("does not count soft-deleted posts", async () => {
+    it("does not count deleted Threads", async () => {
       const col = await collectionService.create({
         slug: "col",
         title: "Col",
@@ -813,19 +868,18 @@ describe("CollectionService", () => {
         bodyMarkdown: "still alive",
       });
 
-      await collectionService.addPost(col.id, post.id);
-      await collectionService.addPost(col.id, post2.id);
+      await collectionService.addThread(col.id, post.id);
+      await collectionService.addThread(col.id, post2.id);
 
-      // Soft-delete one post
       await postService.delete(post.id);
 
-      const counts = await collectionService.getPostCounts();
+      const counts = await collectionService.getThreadCounts();
       expect(counts.get(col.id)).toBe(1);
     });
   });
 
-  describe("addPost / removePost", () => {
-    it("adds a post to a collection", async () => {
+  describe("addThread / removeThread", () => {
+    it("adds a Thread to a collection", async () => {
       const col = await collectionService.create({
         slug: "test",
         title: "Test",
@@ -835,7 +889,7 @@ describe("CollectionService", () => {
         bodyMarkdown: "test",
       });
 
-      await collectionService.addPost(col.id, post.id);
+      await collectionService.addThread(col.id, post.id);
 
       const collections = await collectionService.getCollectionsByPostId(
         post.id,
@@ -854,14 +908,14 @@ describe("CollectionService", () => {
         bodyMarkdown: "test",
       });
 
-      await collectionService.addPost(col.id, post.id);
-      await collectionService.addPost(col.id, post.id); // duplicate
+      await collectionService.addThread(col.id, post.id);
+      await collectionService.addThread(col.id, post.id); // duplicate
 
-      const postIds = await collectionService.getPostIds(col.id);
-      expect(postIds).toHaveLength(1);
+      const threadIds = await collectionService.getThreadIds(col.id);
+      expect(threadIds).toHaveLength(1);
     });
 
-    it("removes a post from a collection", async () => {
+    it("removes a Thread from a collection", async () => {
       const col = await collectionService.create({
         slug: "test",
         title: "Test",
@@ -871,14 +925,43 @@ describe("CollectionService", () => {
         bodyMarkdown: "test",
       });
 
-      await collectionService.addPost(col.id, post.id);
-      await collectionService.removePost(col.id, post.id);
+      await collectionService.addThread(col.id, post.id);
+      await collectionService.removeThread(col.id, post.id);
 
       const collections = await collectionService.getCollectionsByPostId(
         post.id,
       );
       expect(collections).toHaveLength(0);
     });
+
+    it("normalizes Child mutations to the shared Thread root", async () => {
+      const collection = await collectionService.create({
+        slug: "child-mutation",
+        title: "Child Mutation",
+      });
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const child = await postService.create({
+        format: "note",
+        bodyMarkdown: "child",
+        replyToId: root.id,
+      });
+
+      await collectionService.addThread(collection.id, child.id);
+      expect(await collectionService.getThreadIds(collection.id)).toEqual([
+        root.id,
+      ]);
+      expect(
+        (await collectionService.getCollectionsByPostId(root.id)).map(
+          (item) => item.id,
+        ),
+      ).toEqual([collection.id]);
+
+      await collectionService.removeThread(collection.id, child.id);
+      expect(await collectionService.getThreadIds(collection.id)).toEqual([]);
+    });
   });
 
   describe("getCollectionsByPostId", () => {
@@ -899,8 +982,8 @@ describe("CollectionService", () => {
         bodyMarkdown: "test",
       });
 
-      await collectionService.addPost(cols[0]?.id ?? "", post.id);
-      await collectionService.addPost(cols[1]?.id ?? "", post.id);
+      await collectionService.addThread(cols[0]?.id ?? "", post.id);
+      await collectionService.addThread(cols[1]?.id ?? "", post.id);
 
       const collections = await collectionService.getCollectionsByPostId(
         post.id,
@@ -919,10 +1002,70 @@ describe("CollectionService", () => {
       );
       expect(collections).toHaveLength(0);
     });
+
+    it("projects one shared membership set onto the root and every child", async () => {
+      const collection = await collectionService.create({
+        slug: "shared-thread",
+        title: "Shared Thread",
+      });
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const child = await postService.create({
+        format: "note",
+        bodyMarkdown: "child",
+        replyToId: root.id,
+      });
+
+      await collectionService.addThread(collection.id, root.id);
+
+      const [rootCollections, childCollections, batch] = await Promise.all([
+        collectionService.getCollectionsByPostId(root.id),
+        collectionService.getCollectionsByPostId(child.id),
+        collectionService.getCollectionsByPostIds([root.id, child.id]),
+      ]);
+
+      expect(rootCollections.map((item) => item.id)).toEqual([collection.id]);
+      expect(childCollections.map((item) => item.id)).toEqual([collection.id]);
+      expect(batch.get(root.id)?.map((item) => item.id)).toEqual([
+        collection.id,
+      ]);
+      expect(batch.get(child.id)?.map((item) => item.id)).toEqual([
+        collection.id,
+      ]);
+    });
+
+    it("keeps shared membership when a Child is deleted and removes it with the Root", async () => {
+      const collection = await collectionService.create({
+        slug: "thread-lifecycle",
+        title: "Thread Lifecycle",
+      });
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const child = await postService.create({
+        format: "note",
+        bodyMarkdown: "child",
+        replyToId: root.id,
+      });
+      await collectionService.addThread(collection.id, root.id);
+
+      await postService.delete(child.id);
+      expect(
+        (await collectionService.getCollectionsByPostId(root.id)).map(
+          (item) => item.id,
+        ),
+      ).toEqual([collection.id]);
+
+      await postService.delete(root.id);
+      expect(await collectionService.getThreadIds(collection.id)).toEqual([]);
+    });
   });
 
-  describe("getPostIds", () => {
-    it("returns all post IDs in a collection", async () => {
+  describe("getThreadIds", () => {
+    it("returns all Thread root IDs in a collection", async () => {
       const col = await collectionService.create({
         slug: "test",
         title: "Test",
@@ -936,18 +1079,18 @@ describe("CollectionService", () => {
         bodyMarkdown: "two",
       });
 
-      await collectionService.addPost(col.id, p1.id);
-      await collectionService.addPost(col.id, p2.id);
+      await collectionService.addThread(col.id, p1.id);
+      await collectionService.addThread(col.id, p2.id);
 
-      const ids = await collectionService.getPostIds(col.id);
+      const ids = await collectionService.getThreadIds(col.id);
       expect(ids).toHaveLength(2);
       expect(ids).toContain(p1.id);
       expect(ids).toContain(p2.id);
     });
   });
 
-  describe("syncPostCollections", () => {
-    it("replaces all collection memberships for a post", async () => {
+  describe("syncThreadCollections", () => {
+    it("replaces all collection memberships for a Thread", async () => {
       const col1 = await collectionService.create({
         slug: "col1",
         title: "Col 1",
@@ -967,11 +1110,14 @@ describe("CollectionService", () => {
       });
 
       // Initially in col1 and col2
-      await collectionService.addPost(col1.id, post.id);
-      await collectionService.addPost(col2.id, post.id);
+      await collectionService.addThread(col1.id, post.id);
+      await collectionService.addThread(col2.id, post.id);
 
       // Sync to col2 and col3
-      await collectionService.syncPostCollections(post.id, [col2.id, col3.id]);
+      await collectionService.syncThreadCollections(post.id, [
+        col2.id,
+        col3.id,
+      ]);
 
       const collections = await collectionService.getCollectionsByPostId(
         post.id,
@@ -993,8 +1139,8 @@ describe("CollectionService", () => {
         bodyMarkdown: "test",
       });
 
-      await collectionService.addPost(col.id, post.id);
-      await collectionService.syncPostCollections(post.id, []);
+      await collectionService.addThread(col.id, post.id);
+      await collectionService.syncThreadCollections(post.id, []);
 
       const collections = await collectionService.getCollectionsByPostId(
         post.id,
@@ -1018,13 +1164,13 @@ describe("CollectionService", () => {
       const originalTransaction = dbWithoutTransaction.transaction.bind(db);
       dbWithoutTransaction.transaction = async () => {
         throw new Error(
-          "sqlite syncPostCollections() should not call transaction()",
+          "sqlite syncThreadCollections() should not call transaction()",
         );
       };
 
       try {
         await expect(
-          collectionService.syncPostCollections(post.id, [col.id]),
+          collectionService.syncThreadCollections(post.id, [col.id]),
         ).resolves.toBeUndefined();
       } finally {
         dbWithoutTransaction.transaction = originalTransaction;