@jant/core 0.6.14 → 0.6.16

package/src/routes/api/internal/__tests__/post-body-html.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import { eq } from "drizzle-orm";
+import { createTestApp } from "../../../../__tests__/helpers/app.js";
+import { posts, sites } from "../../../../db/schema.js";
+import { POST_BODY_HTML_VERSION } from "../../../../lib/post-body-html.js";
+import { createPostService } from "../../../../services/post.js";
+import { internalPostBodyHtmlRoutes } from "../post-body-html.js";
+import { internalSitesRoutes } from "../sites.js";
+
+describe("Internal post body HTML rebuild routes", () => {
+  it("hides the current-site endpoint when no internal token is configured", async () => {
+    const { app } = createTestApp({ authenticated: false });
+    app.route("/api/internal/posts/body-html", internalPostBodyHtmlRoutes);
+
+    const response = await app.request(
+      "/api/internal/posts/body-html/rebuild",
+      { method: "POST" },
+    );
+
+    expect(response.status).toBe(404);
+  });
+
+  it("dry-runs and rebuilds the current site", async () => {
+    const { app, services, db } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+    });
+    app.use("*", async (c, next) => {
+      c.set("appConfig", undefined as never);
+      await next();
+    });
+    app.route("/api/internal/posts/body-html", internalPostBodyHtmlRoutes);
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Body[^1]\n\n[^1]: Definition",
+    });
+    await db
+      .update(posts)
+      .set({
+        bodyHtml: '<span class="sidenote">legacy</span>',
+        bodyHtmlVersion: 1,
+      })
+      .where(eq(posts.id, post.id));
+
+    const dryRun = await app.request("/api/internal/posts/body-html/rebuild", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer internal-secret",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ dryRun: true, limit: 25 }),
+    });
+    expect(dryRun.status).toBe(200);
+    await expect(dryRun.json()).resolves.toMatchObject({
+      processed: 1,
+      wouldRebuild: 1,
+      rebuilt: 0,
+      targetVersion: POST_BODY_HTML_VERSION,
+    });
+
+    const rebuild = await app.request("/api/internal/posts/body-html/rebuild", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer internal-secret",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ limit: 25 }),
+    });
+    expect(rebuild.status).toBe(200);
+    await expect(rebuild.json()).resolves.toMatchObject({
+      rebuilt: 1,
+      failed: 0,
+    });
+  });
+
+  it("rebuilds only the explicitly selected managed site", async () => {
+    const { app, services, db } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+      siteResolutionMode: "host-based",
+    });
+    app.use("*", async (c, next) => {
+      c.set("appConfig", undefined as never);
+      await next();
+    });
+    app.route("/api/internal/sites", internalSitesRoutes);
+
+    const timestamp = Math.floor(Date.now() / 1000);
+    const secondSiteId = "sit_managed00000000000000000000";
+    await db.insert(sites).values({
+      id: secondSiteId,
+      key: "managed",
+      status: "active",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+    const defaultPost = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Default",
+    });
+    const managedService = createPostService(
+      db,
+      { slugIdLength: 5 },
+      secondSiteId,
+    );
+    const managedPost = await managedService.create({
+      format: "note",
+      bodyMarkdown: "Managed[^1]\n\n[^1]: Definition",
+    });
+    await db
+      .update(posts)
+      .set({ bodyHtmlVersion: 1 })
+      .where(eq(posts.id, defaultPost.id));
+    await db
+      .update(posts)
+      .set({ bodyHtmlVersion: 1 })
+      .where(eq(posts.id, managedPost.id));
+
+    const response = await app.request(
+      `/api/internal/sites/${secondSiteId}/posts/body-html/rebuild`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer internal-secret",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({}),
+      },
+    );
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      processed: 1,
+      rebuilt: 1,
+    });
+
+    const rows = await db
+      .select({ id: posts.id, version: posts.bodyHtmlVersion })
+      .from(posts);
+    expect(rows.find((row) => row.id === managedPost.id)?.version).toBe(
+      POST_BODY_HTML_VERSION,
+    );
+    expect(rows.find((row) => row.id === defaultPost.id)?.version).toBe(1);
+  });
+
+  it("rejects an unknown explicit site instead of reporting an empty success", async () => {
+    const { app } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+      siteResolutionMode: "host-based",
+    });
+    app.route("/api/internal/sites", internalSitesRoutes);
+
+    const response = await app.request(
+      "/api/internal/sites/sit_missing/posts/body-html/rebuild",
+      {
+        method: "POST",
+        headers: { Authorization: "Bearer internal-secret" },
+      },
+    );
+
+    expect(response.status).toBe(404);
+  });
+});

package/src/routes/api/internal/__tests__/sites.test.ts

@@ -120,7 +120,7 @@ describe("Internal site admin routes", () => {
         primaryHost: "locale-demo.example.com",
         siteName: "Locale Demo",
         siteLanguage: "en-US",
-        timeZone: "Asia/Shanghai",
+        timeZone: "Etc/GMT-8",
       }),
     });
 
@@ -139,10 +139,43 @@ describe("Internal site admin routes", () => {
       { key: "ONBOARDING_STATUS", value: "completed" },
       { key: "SITE_LANGUAGE", value: "en" },
       { key: "SITE_NAME", value: "Locale Demo" },
-      { key: "TIME_ZONE", value: "Asia/Shanghai" },
+      { key: "TIME_ZONE", value: "Etc/GMT-8" },
     ]);
   });
 
+  it("falls back to UTC instead of rejecting invalid browser timezone metadata", async () => {
+    const { app, sqlite } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+      siteResolutionMode: "host-based",
+    });
+    app.route("/api/internal/sites", internalSitesRoutes);
+
+    const res = await app.request("/api/internal/sites", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer internal-secret",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        key: "timezone-fallback",
+        primaryHost: "timezone-fallback.example.com",
+        siteName: "Timezone Fallback",
+        timeZone: "Unknown/Zone",
+      }),
+    });
+
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as { siteId: string };
+    const timeZone = sqlite
+      .prepare(
+        'SELECT "value" FROM "site_setting" WHERE "site_id" = ? AND "key" = \'TIME_ZONE\'',
+      )
+      .get(body.siteId);
+
+    expect(timeZone).toBeUndefined();
+  });
+
   it("reports an unused key as available", async () => {
     const { app } = createTestApp({
       authenticated: false,

package/src/routes/api/internal/post-body-html.ts

@@ -0,0 +1,43 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { requireInternalAdminApi } from "../../../middleware/auth.js";
+import { parseValidated } from "../../../lib/schemas.js";
+import { rebuildPostBodyHtmlWithRuntimeSettings } from "../../../services/post.js";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const RebuildPostBodyHtmlSchema = z.object({
+  limit: z.number().int().positive().max(100).optional(),
+  cursor: z.string().trim().min(1).optional(),
+  dryRun: z.boolean().optional(),
+});
+
+export const internalPostBodyHtmlRoutes = new Hono<Env>();
+
+/**
+ * Rebuild the current site's materialized post body HTML projection.
+ *
+ * Callers follow `nextCursor` until `done`. The service owns rendering,
+ * compare-and-swap writes, and timestamp preservation; this route only
+ * validates the authenticated maintenance request.
+ */
+internalPostBodyHtmlRoutes.post(
+  "/rebuild",
+  requireInternalAdminApi(),
+  async (c) => {
+    const contentType = c.req.header("Content-Type") || "";
+    const rawBody = contentType.includes("application/json")
+      ? await c.req.json().catch(() => ({}))
+      : {};
+    const body = parseValidated(RebuildPostBodyHtmlSchema, rawBody);
+
+    const result = await rebuildPostBodyHtmlWithRuntimeSettings(
+      c.var.services,
+      c.env,
+      body,
+    );
+    return c.json(result);
+  },
+);

package/src/routes/api/internal/sites.ts

@@ -3,12 +3,14 @@ import { z } from "zod";
 import { requireInternalAdminApi } from "../../../middleware/auth.js";
 import { ConflictError } from "../../../lib/errors.js";
 import { parseValidated } from "../../../lib/schemas.js";
+import { rebuildPostBodyHtmlWithRuntimeSettings } from "../../../services/post.js";
 import {
   getConfiguredStorageDriver,
   getSiteResolutionMode,
 } from "../../../lib/env.js";
 import type { Bindings } from "../../../types.js";
 import type { AppVariables } from "../../../types/app-context.js";
+import { RebuildPostBodyHtmlSchema } from "./post-body-html.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -199,6 +201,28 @@ internalSitesRoutes.post(
   },
 );
 
+// Rebuild one managed site's materialized body HTML projection. Hosted fleet
+// orchestration stays in the control plane; core never silently widens a
+// content-facing operation to every tenant.
+internalSitesRoutes.post(
+  "/:siteId/posts/body-html/rebuild",
+  requireInternalAdminApi(),
+  async (c) => {
+    assertHostBasedMode(c.env);
+
+    const contentType = c.req.header("Content-Type") || "";
+    const rawBody = contentType.includes("application/json")
+      ? await c.req.json().catch(() => ({}))
+      : {};
+    const body = parseValidated(RebuildPostBodyHtmlSchema, rawBody);
+    const services = c.var.servicesForSite(c.req.param("siteId"));
+
+    return c.json(
+      await rebuildPostBodyHtmlWithRuntimeSettings(services, c.env, body),
+    );
+  },
+);
+
 internalSitesRoutes.get(
   "/:siteId/export",
   requireInternalAdminApi(),

package/src/routes/api/nav-items.ts

@@ -8,6 +8,7 @@ import { z } from "zod";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { requireAuthApi } from "../../middleware/auth.js";
+import { requirePublicApiAccess } from "../../middleware/public-content-access.js";
 import {
   CreateNavItemSchema,
   NavItemIdSchema,
@@ -31,6 +32,11 @@ const MoveSchema = z.object({
   before: NavItemIdSchema.nullable().optional(),
 });
 
+const PageCandidatesQuerySchema = z.object({
+  q: z.string().trim().max(200).optional(),
+  limit: z.coerce.number().int().min(1).max(50).optional(),
+});
+
 async function withSiteHeaderHtml<T extends object>(
   c: Context<Env>,
   body: T,
@@ -48,11 +54,21 @@ async function withSiteHeaderHtml<T extends object>(
 }
 
 // List nav items
-navItemsApiRoutes.get("/", async (c) => {
+navItemsApiRoutes.get("/", requirePublicApiAccess(), async (c) => {
   const items = await c.var.services.navItems.list();
   return c.json({ navItems: items });
 });
 
+// Search published titled notes that can be added as pages (requires auth)
+navItemsApiRoutes.get("/pages", requireAuthApi(), async (c) => {
+  const query = parseValidated(PageCandidatesQuerySchema, c.req.query());
+  const pages = await c.var.services.navItems.listPageCandidates({
+    query: query.q,
+    limit: query.limit,
+  });
+  return c.json({ pages });
+});
+
 // Move nav item (requires auth) — must be before /:id
 navItemsApiRoutes.put("/:id/move", requireAuthApi(), async (c) => {
   const id = parseIdParam(c.req.param("id"), ID_PREFIX.navItem);
@@ -94,6 +110,13 @@ navItemsApiRoutes.post("/", requireAuthApi(), async (c) => {
       url: getCollectionPagePath(collection.slug),
       placement: body.placement,
     });
+  } else if (body.type === "page") {
+    item = await c.var.services.navItems.create({
+      type: "page",
+      postId: body.postId,
+      label: body.label,
+      placement: body.placement,
+    });
   } else {
     item = await c.var.services.navItems.create({
       type: "link",

package/src/routes/api/posts.ts

@@ -131,12 +131,15 @@ postsApiRoutes.get("/:id/content", requireAuthApi(), async (c) => {
 postsApiRoutes.get("/:id", requireAuthApi(), async (c) => {
   const id = parseIdParam(c.req.param("id"), ID_PREFIX.post);
 
-  // Fetch post, media, and collections in parallel (all keyed by the same id)
-  const [post, mediaList, postCollections] = await Promise.all([
-    c.var.services.posts.getById(id),
-    c.var.services.media.getByPostId(id),
-    c.var.services.collections.getCollectionsByPostId(id),
-  ]);
+  // Fetch post, media, collections and thread position in parallel (all keyed
+  // by the same id)
+  const [post, mediaList, threadCollections, threadPosition] =
+    await Promise.all([
+      c.var.services.posts.getById(id),
+      c.var.services.media.getByPostId(id),
+      c.var.services.collections.getCollectionsByPostId(id),
+      c.var.services.posts.getThreadPosition(id),
+    ]);
   const foundPost = assertFound(post, "Post");
   const {
     r2PublicUrl,
@@ -145,10 +148,10 @@ postsApiRoutes.get("/:id", requireAuthApi(), async (c) => {
     localPublicUrl,
     sitePathPrefix,
   } = c.var.appConfig;
-  const collectionIds = postCollections.map((col) => col.id);
+  const collectionIds = threadCollections.map((col) => col.id);
 
-  return c.json(
-    toApiPost(foundPost, {
+  return c.json({
+    ...toApiPost(foundPost, {
       collectionIds,
       attachments: mediaList.map((m) =>
         toApiAttachment(
@@ -161,7 +164,8 @@ postsApiRoutes.get("/:id", requireAuthApi(), async (c) => {
         ),
       ),
     }),
-  );
+    threadPosition,
+  });
 });
 
 // Create post (requires auth)

package/src/routes/api/public/__tests__/archive.test.ts

@@ -88,6 +88,41 @@ describe("Public Archive API Routes", () => {
       expect(nextBody.posts[0].id).not.toBe(body.posts[0].id);
     });
 
+    it("paginates chronologically without promoting pinned posts", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const olderPinned = await services.posts.create({
+        format: "note",
+        title: "Older pinned post",
+        bodyMarkdown: "older",
+        pinned: true,
+        publishedAt: Date.UTC(2025, 0, 1) / 1000,
+      });
+      const newerUnpinned = await services.posts.create({
+        format: "note",
+        title: "Newer unpinned post",
+        bodyMarkdown: "newer",
+        publishedAt: Date.UTC(2026, 0, 1) / 1000,
+      });
+
+      const first = await app.request("/api/public/archive?limit=1");
+      expect(first.status).toBe(200);
+      const firstBody = await first.json();
+      expect(firstBody.posts.map((post: { id: string }) => post.id)).toEqual([
+        newerUnpinned.id,
+      ]);
+
+      const second = await app.request(
+        `/api/public/archive?limit=1&cursor=${firstBody.nextCursor}`,
+      );
+      expect(second.status).toBe(200);
+      const secondBody = await second.json();
+      expect(secondBody.posts.map((post: { id: string }) => post.id)).toEqual([
+        olderPinned.id,
+      ]);
+    });
+
     it("filters by year using publishedAt", async () => {
       const { app, services } = createTestApp({ authenticated: false });
       app.route("/api/public/archive", publicArchiveApiRoutes);