@jant/core 0.3.36 → 0.3.38

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);
+    });
+  });
+});