@jant/core 0.3.26 → 0.3.28

package/src/routes/auth/__tests__/setup.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { createTestDatabase } from "../../../__tests__/helpers/db.js";
+import { createPageService } from "../../../services/page.js";
+import { createSettingsService } from "../../../services/settings.js";
+import { createNavItemService } from "../../../services/navigation.js";
+import type { Database } from "../../../db/index.js";
+import type { PageService } from "../../../services/page.js";
+import type { SettingsService } from "../../../services/settings.js";
+import type { NavItemService } from "../../../services/navigation.js";
+
+/**
+ * Reproduces the seed logic from POST /setup to verify the default About page
+ * and navigation items are created correctly.
+ */
+async function runSetupSeed(services: {
+  pages: PageService;
+  settings: SettingsService;
+  navItems: NavItemService;
+}) {
+  await services.settings.completeOnboarding();
+
+  await services.navItems.create({
+    type: "link",
+    label: "Collections",
+    url: "/collections",
+  });
+  await services.navItems.create({
+    type: "link",
+    label: "Archive",
+    url: "/archive",
+  });
+
+  const aboutPage = await services.pages.create({
+    slug: "about",
+    title: "About",
+    body: [
+      "Welcome to my corner of the internet.",
+      "",
+      "This is a place where I share my thoughts, ideas, and things I find interesting. Feel free to look around and get to know what this site is all about.",
+      "",
+      "If you'd like to get in touch, don't hesitate to reach out.",
+    ].join("\n"),
+    status: "published",
+  });
+
+  await services.navItems.create({
+    type: "page",
+    label: "About",
+    url: "/about",
+    pageId: aboutPage.id,
+  });
+}
+
+describe("Setup seed logic", () => {
+  let services: {
+    pages: PageService;
+    settings: SettingsService;
+    navItems: NavItemService;
+  };
+
+  beforeEach(() => {
+    const testDb = createTestDatabase();
+    const db = testDb.db as unknown as Database;
+    services = {
+      pages: createPageService(db),
+      settings: createSettingsService(db),
+      navItems: createNavItemService(db),
+    };
+  });
+
+  it("creates a default About page with correct content", async () => {
+    await runSetupSeed(services);
+
+    const aboutPage = await services.pages.getBySlug("about");
+    expect(aboutPage).not.toBeNull();
+    expect(aboutPage?.title).toBe("About");
+    expect(aboutPage?.status).toBe("published");
+    expect(aboutPage?.body).toContain("Welcome to my corner of the internet");
+    expect(aboutPage?.bodyHtml).toBeTruthy();
+  });
+
+  it("adds About page to navigation as a page-type nav item", async () => {
+    await runSetupSeed(services);
+
+    const aboutPage = await services.pages.getBySlug("about");
+    const navItemsList = await services.navItems.list();
+
+    const aboutNavItem = navItemsList.find(
+      (item) => item.pageId === aboutPage?.id,
+    );
+    expect(aboutNavItem).toBeDefined();
+    expect(aboutNavItem?.type).toBe("page");
+    expect(aboutNavItem?.label).toBe("About");
+    expect(aboutNavItem?.url).toBe("/about");
+  });
+
+  it("creates three nav items total: Collections, Archive, About", async () => {
+    await runSetupSeed(services);
+
+    const navItemsList = await services.navItems.list();
+    expect(navItemsList).toHaveLength(3);
+
+    const labels = navItemsList.map((item) => item.label);
+    expect(labels).toContain("Collections");
+    expect(labels).toContain("Archive");
+    expect(labels).toContain("About");
+  });
+
+  it("renders About page body as HTML", async () => {
+    await runSetupSeed(services);
+
+    const aboutPage = await services.pages.getBySlug("about");
+    expect(aboutPage?.bodyHtml).toContain("<p>");
+    expect(aboutPage?.bodyHtml).toContain(
+      "Welcome to my corner of the internet",
+    );
+  });
+});

package/src/routes/auth/reset.tsx

@@ -6,14 +6,14 @@
 
 import { Hono } from "hono";
 import type { FC } from "hono/jsx";
+import { msg } from "@lingui/core/macro";
 import { useLingui } from "@lingui/react/macro";
-import { hashPassword } from "better-auth/crypto";
 import type { Bindings } from "../../types.js";
-import type { AppVariables } from "../../app.js";
+import type { AppVariables } from "../../types/app-context.js";
 import { BaseLayout } from "../../ui/layouts/BaseLayout.js";
 import { dsRedirect, dsToast } from "../../lib/sse.js";
-import { SETTINGS_KEYS } from "../../lib/constants.js";
 import { ResetPasswordSchema } from "../../lib/schemas.js";
+import { getI18n } from "../../i18n/index.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -137,25 +137,6 @@ const ResetErrorContent: FC = () => {
   );
 };
 
-/**
- * Validate a password reset token against the stored value.
- * Returns true if the token is valid and not expired.
- */
-async function validateResetToken(
-  settings: { get(key: string): Promise<string | null> },
-  token: string,
-): Promise<boolean> {
-  const stored = await settings.get(SETTINGS_KEYS.PASSWORD_RESET_TOKEN);
-  if (!stored) return false;
-
-  const separatorIndex = stored.lastIndexOf(":");
-  const storedToken = stored.substring(0, separatorIndex);
-  const expiry = parseInt(stored.substring(separatorIndex + 1), 10);
-  const now = Math.floor(Date.now() / 1000);
-
-  return token === storedToken && now <= expiry;
-}
-
 export const resetRoutes = new Hono<Env>();
 
 resetRoutes.get("/reset", async (c) => {
@@ -168,7 +149,7 @@ resetRoutes.get("/reset", async (c) => {
     );
   }
 
-  const isValid = await validateResetToken(c.var.services.settings, token);
+  const isValid = await c.var.services.auth.validateResetToken(token);
   if (!isValid) {
     return c.html(
       <BaseLayout title="Reset Password - Jant" c={c}>
@@ -185,55 +166,25 @@ resetRoutes.get("/reset", async (c) => {
 });
 
 resetRoutes.post("/reset", async (c) => {
+  const i18n = getI18n(c);
   const body = await c.req.json();
   const parsed = ResetPasswordSchema.safeParse(body);
 
   if (!parsed.success) {
-    const msg = parsed.error.errors[0]?.message ?? "Invalid input";
-    return dsToast(msg, "error");
+    const errorMsg =
+      parsed.error.issues[0]?.message ??
+      i18n._(
+        msg({
+          message: "Invalid input",
+          comment:
+            "@context: Fallback validation error for password reset form",
+        }),
+      );
+    return dsToast(errorMsg, "error");
   }
 
   const { password, token } = parsed.data;
 
-  // Validate token
-  const isValid = await validateResetToken(c.var.services.settings, token);
-  if (!isValid) {
-    return dsToast("Invalid or expired reset link.", "error");
-  }
-
-  try {
-    const hashedPassword = await hashPassword(password);
-    const db = c.env.DB.withSession() as unknown as D1Database;
-
-    // Get admin user
-    const userResult = await db
-      .prepare("SELECT id FROM user LIMIT 1")
-      .first<{ id: string }>();
-    if (!userResult) {
-      return dsToast("No user account found.", "error");
-    }
-
-    // Update password
-    await db
-      .prepare(
-        "UPDATE account SET password = ? WHERE user_id = ? AND provider_id = 'credential'",
-      )
-      .bind(hashedPassword, userResult.id)
-      .run();
-
-    // Delete all sessions
-    await db
-      .prepare("DELETE FROM session WHERE user_id = ?")
-      .bind(userResult.id)
-      .run();
-
-    // Delete the reset token
-    await c.var.services.settings.remove(SETTINGS_KEYS.PASSWORD_RESET_TOKEN);
-
-    return dsRedirect("/signin?reset");
-  } catch (err) {
-    // eslint-disable-next-line no-console -- Error logging is intentional
-    console.error("Password reset error:", err);
-    return dsToast("Failed to reset password.", "error");
-  }
+  await c.var.services.auth.resetPassword(token, password);
+  return dsRedirect("/signin?reset");
 });

package/src/routes/auth/setup.tsx

@@ -6,13 +6,15 @@
 
 import { Hono } from "hono";
 import type { FC } from "hono/jsx";
+import { msg } from "@lingui/core/macro";
 import { useLingui } from "@lingui/react/macro";
 import type { Bindings } from "../../types.js";
-import type { AppVariables } from "../../app.js";
+import type { AppVariables } from "../../types/app-context.js";
 import { BaseLayout } from "../../ui/layouts/BaseLayout.js";
 import { dsRedirect, dsToast } from "../../lib/sse.js";
 import { SetupSchema } from "../../lib/schemas.js";
 import { mapIanaToTimezone } from "../../lib/timezones.js";
+import { getI18n } from "../../i18n/index.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -131,6 +133,7 @@ setupRoutes.get("/setup", async (c) => {
 });
 
 setupRoutes.post("/setup", async (c) => {
+  const i18n = getI18n(c);
   const isComplete = await c.var.services.settings.isOnboardingComplete();
   if (isComplete) return c.redirect("/");
 
@@ -139,14 +142,30 @@ setupRoutes.post("/setup", async (c) => {
   const browserTimezone = body._timezone;
 
   if (!parsed.success) {
-    const msg = parsed.error.errors[0]?.message ?? "Invalid input";
-    return dsToast(msg, "error");
+    const errorMsg =
+      parsed.error.issues[0]?.message ??
+      i18n._(
+        msg({
+          message: "Invalid input",
+          comment: "@context: Fallback validation error for setup form",
+        }),
+      );
+    return dsToast(errorMsg, "error");
   }
 
   const { name, email, password } = parsed.data;
 
   if (!c.var.auth) {
-    return dsToast("AUTH_SECRET not configured", "error");
+    return dsToast(
+      i18n._(
+        msg({
+          message: "AUTH_SECRET not configured",
+          comment:
+            "@context: Error toast when authentication secret is missing from server config",
+        }),
+      ),
+      "error",
+    );
   }
 
   try {
@@ -155,7 +174,15 @@ setupRoutes.post("/setup", async (c) => {
     });
 
     if (!signUpResponse || "error" in signUpResponse) {
-      return dsToast("Failed to create account", "error");
+      return dsToast(
+        i18n._(
+          msg({
+            message: "Failed to create account",
+            comment: "@context: Error toast when account creation fails",
+          }),
+        ),
+        "error",
+      );
     }
 
     await c.var.services.settings.completeOnboarding();
@@ -168,22 +195,51 @@ setupRoutes.post("/setup", async (c) => {
       }
     }
 
-    // Seed default navigation items
     await c.var.services.navItems.create({
       type: "link",
-      label: "Featured",
-      url: "/featured",
+      label: "Collections",
+      url: "/collections",
     });
+    // Seed default navigation items
     await c.var.services.navItems.create({
       type: "link",
-      label: "Collections",
-      url: "/collections",
+      label: "Archive",
+      url: "/archive",
+    });
+
+    // Seed default About page
+    const aboutPage = await c.var.services.pages.create({
+      slug: "about",
+      title: "About",
+      body: [
+        "Welcome to my corner of the internet.",
+        "",
+        "This is a place where I share my thoughts, ideas, and things I find interesting. Feel free to look around and get to know what this site is all about.",
+        "",
+        "If you'd like to get in touch, don't hesitate to reach out.",
+      ].join("\n"),
+      status: "published",
+    });
+
+    await c.var.services.navItems.create({
+      type: "page",
+      label: "About",
+      url: "/about",
+      pageId: aboutPage.id,
     });
 
     return dsRedirect("/signin?setup");
   } catch (err) {
     // eslint-disable-next-line no-console -- Error logging is intentional
     console.error("Setup error:", err);
-    return dsToast("Failed to create account", "error");
+    return dsToast(
+      i18n._(
+        msg({
+          message: "Failed to create account",
+          comment: "@context: Error toast when account creation fails",
+        }),
+      ),
+      "error",
+    );
   }
 });

package/src/routes/auth/signin.tsx

@@ -4,12 +4,14 @@
 
 import { Hono } from "hono";
 import type { FC } from "hono/jsx";
+import { msg } from "@lingui/core/macro";
 import { useLingui } from "@lingui/react/macro";
 import type { Bindings } from "../../types.js";
-import type { AppVariables } from "../../app.js";
+import type { AppVariables } from "../../types/app-context.js";
 import { BaseLayout } from "../../ui/layouts/BaseLayout.js";
 import { dsRedirect, dsToast } from "../../lib/sse.js";
 import { SigninSchema } from "../../lib/schemas.js";
+import { getI18n } from "../../i18n/index.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -116,24 +118,42 @@ signinRoutes.get("/signin", async (c) => {
   return c.html(
     <BaseLayout title="Sign In - Jant" c={c} toast={toast}>
       <SigninContent
-        demoEmail={c.env.DEMO_EMAIL}
-        demoPassword={c.env.DEMO_PASSWORD}
+        demoEmail={c.var.appConfig.demoEmail}
+        demoPassword={c.var.appConfig.demoPassword}
       />
     </BaseLayout>,
   );
 });
 
 signinRoutes.post("/signin", async (c) => {
+  const i18n = getI18n(c);
+
   if (!c.var.auth) {
-    return dsToast("Auth not configured", "error");
+    return dsToast(
+      i18n._(
+        msg({
+          message: "Auth not configured",
+          comment:
+            "@context: Error toast when authentication system is unavailable",
+        }),
+      ),
+      "error",
+    );
   }
 
   const body = await c.req.json();
   const parsed = SigninSchema.safeParse(body);
 
   if (!parsed.success) {
-    const msg = parsed.error.errors[0]?.message ?? "Invalid input";
-    return dsToast(msg, "error");
+    const errorMsg =
+      parsed.error.issues[0]?.message ??
+      i18n._(
+        msg({
+          message: "Invalid input",
+          comment: "@context: Fallback validation error for sign-in form",
+        }),
+      );
+    return dsToast(errorMsg, "error");
   }
 
   const { email, password } = parsed.data;
@@ -147,14 +167,30 @@ signinRoutes.post("/signin", async (c) => {
 
     return dsRedirect("/dash", { headers });
   } catch {
-    return dsToast("Invalid email or password", "error");
+    return dsToast(
+      i18n._(
+        msg({
+          message: "Invalid email or password",
+          comment: "@context: Error toast when sign-in credentials are wrong",
+        }),
+      ),
+      "error",
+    );
   }
 });
 
 signinRoutes.get("/signout", async (c) => {
   if (c.var.auth) {
     try {
-      await c.var.auth.api.signOut({ headers: c.req.raw.headers });
+      const res = await c.var.auth.api.signOut({
+        headers: c.req.raw.headers,
+        asResponse: true,
+      });
+      const redirect = c.redirect("/");
+      for (const cookie of res.headers.getSetCookie()) {
+        redirect.headers.append("Set-Cookie", cookie);
+      }
+      return redirect;
     } catch {
       // Ignore signout errors
     }

package/src/routes/compose.tsx

@@ -0,0 +1,194 @@
+/**
+ * Compose Route
+ *
+ * Handles post creation from the public-site compose dialog.
+ * Published posts are prepended to the homepage timeline via SSE.
+ * Drafts close the dialog and show a confirmation toast.
+ */
+
+import { Hono, type Context } from "hono";
+import { msg } from "@lingui/core/macro";
+import type { Bindings, Post } from "../types.js";
+import type { AppVariables } from "../types/app-context.js";
+import { requireAuth } from "../middleware/auth.js";
+import { CreatePostSchema, validateMediaCount } from "../lib/schemas.js";
+import { sse, dsToast } from "../lib/sse.js";
+import { getI18n } from "../i18n/index.js";
+import {
+  toPostView,
+  toPostViewFromPost,
+  createMediaContext,
+} from "../lib/view.js";
+import { buildMediaMap } from "../lib/media-helpers.js";
+import { TimelineItemFromPost } from "../ui/feed/TimelineItem.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const composeRoutes = new Hono<Env>();
+
+// All compose routes require authentication
+composeRoutes.use("*", requireAuth());
+
+/** Reset compose form signals to initial values */
+const INITIAL_SIGNALS = {
+  format: "note",
+  title: "",
+  body: "",
+  url: "",
+  quoteText: "",
+  status: "published",
+  rating: 0,
+  collectionIds: [],
+  mediaIds: [],
+  _composeLoading: false,
+  _showRating: false,
+  _showCollection: false,
+};
+
+/** Script fragment that closes the compose dialog and self-removes */
+const CLOSE_DIALOG_SCRIPT =
+  "<script data-effect=\"el.remove()\">document.getElementById('compose-dialog').close()</script>";
+
+/** Build a timeline card HTML string for a newly created post */
+async function buildTimelineCard(
+  c: Context<Env>,
+  post: Post,
+  mediaIds: string[] | undefined,
+): Promise<string> {
+  const mediaCtx = createMediaContext(c.var.appConfig);
+  let postView;
+
+  if (mediaIds && mediaIds.length > 0) {
+    const rawMediaMap = await c.var.services.media.getByPostIds([post.id]);
+    const mediaMap = buildMediaMap(
+      rawMediaMap,
+      mediaCtx.r2PublicUrl,
+      mediaCtx.imageTransformUrl,
+      mediaCtx.s3PublicUrl,
+    );
+    postView = toPostView(
+      { ...post, mediaAttachments: mediaMap.get(post.id) ?? [] },
+      mediaCtx,
+    );
+  } else {
+    postView = toPostViewFromPost(post, mediaCtx);
+  }
+
+  return (
+    <div>
+      <TimelineItemFromPost post={postView} />
+      <hr class="feed-divider" />
+    </div>
+  ).toString();
+}
+
+composeRoutes.post("/", async (c) => {
+  const i18n = getI18n(c);
+  const raw = await c.req.json();
+  const wantsJson = c.req.header("accept")?.includes("application/json");
+
+  const result = CreatePostSchema.safeParse(raw);
+  if (!result.success) {
+    const firstError =
+      result.error.issues[0]?.message ??
+      i18n._(
+        msg({
+          message: "Invalid input",
+          comment: "@context: Fallback validation error for compose form",
+        }),
+      );
+    if (wantsJson) {
+      return c.json({ status: "error" as const, error: firstError }, 422);
+    }
+    return dsToast(firstError, "error");
+  }
+
+  const data = result.data;
+
+  // Validate media count
+  if (data.mediaIds) {
+    const mediaError = validateMediaCount(data.mediaIds);
+    if (mediaError) {
+      return dsToast(mediaError, "error");
+    }
+  }
+
+  const post = await c.var.services.posts.create({
+    format: data.format,
+    title: data.title || undefined,
+    body: data.body || undefined,
+    status: data.status ?? "published",
+    url: data.url || undefined,
+    quoteText: data.quoteText || undefined,
+    rating: data.rating || undefined,
+    collectionIds: data.collectionIds?.length ? data.collectionIds : undefined,
+  });
+
+  // Attach media if provided
+  if (data.mediaIds && data.mediaIds.length > 0) {
+    await c.var.services.media.attachToPost(post.id, data.mediaIds);
+
+    // Save alt text for each media item
+    if (data.mediaAlts) {
+      const altEntries = Object.entries(data.mediaAlts).filter(
+        ([id, alt]) => alt && (data.mediaIds ?? []).includes(id),
+      );
+      await Promise.all(
+        altEntries.map(([id, alt]) => c.var.services.media.updateAlt(id, alt)),
+      );
+    }
+  }
+
+  const isDraft = (data.status ?? "published") === "draft";
+
+  // ── JSON response mode (used by Lit compose bridge) ──────────────
+  if (wantsJson) {
+    if (isDraft) {
+      return c.json({
+        status: "draft" as const,
+        toast: i18n._(
+          msg({
+            message: "Draft saved.",
+            comment: "@context: Toast after saving a draft post",
+          }),
+        ),
+      });
+    }
+
+    const cardHtml = await buildTimelineCard(c, post, data.mediaIds);
+    return c.json({ status: "published" as const, cardHtml });
+  }
+
+  // ── SSE response mode (used by Datastar) ─────────────────────────
+  if (isDraft) {
+    return sse(c, async (stream) => {
+      await stream.patchElements(CLOSE_DIALOG_SCRIPT, {
+        mode: "append",
+        selector: "body",
+      });
+      await stream.patchSignals(INITIAL_SIGNALS);
+      await stream.toast(
+        i18n._(
+          msg({
+            message: "Draft saved.",
+            comment: "@context: Toast after saving a draft post",
+          }),
+        ),
+      );
+    });
+  }
+
+  const cardHtml = await buildTimelineCard(c, post, data.mediaIds);
+
+  return sse(c, async (stream) => {
+    await stream.patchElements(cardHtml, {
+      mode: "prepend",
+      selector: "#timeline-items",
+    });
+    await stream.patchElements(CLOSE_DIALOG_SCRIPT, {
+      mode: "append",
+      selector: "body",
+    });
+    await stream.patchSignals(INITIAL_SIGNALS);
+  });
+});