@jant/core 0.6.15 → 0.7.0

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

@@ -0,0 +1,310 @@
+/**
+ * Tests for which of the two self-hosted setup screens a request gets.
+ *
+ * The step is never in the URL. It is read from the onboarding status and, on
+ * the second screen, from whether the site has a name yet — the only records
+ * that survive a closed tab, a reload, or a back button. These cover the route
+ * making that choice; `setup-page.test.tsx` covers what each screen then says.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { Hono } from "hono";
+import { createI18n } from "../../../i18n/index.js";
+import { attachSession } from "../../../middleware/session.js";
+import { ONBOARDING_STATUS } from "../../../lib/constants.js";
+import { setupRoutes } from "../setup.js";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+const SESSION_COOKIE = "jant.session_token=abc; Path=/; HttpOnly";
+
+function createMockAuth(signedIn: boolean) {
+  const signUpEmail = vi.fn(async () => ({
+    headers: new Headers({ "Set-Cookie": SESSION_COOKIE }),
+    response: { user: { id: "usr_new-owner" } },
+  }));
+  const updateUser = vi.fn(async () => ({}));
+
+  return {
+    signUpEmail,
+    updateUser,
+    auth: {
+      api: {
+        signUpEmail,
+        updateUser,
+        getSession: async () => ({
+          headers: new Headers(),
+          response: signedIn
+            ? {
+                user: { id: "usr_owner", email: "owner@test.com", name: "O" },
+                session: { id: "ses_owner" },
+              }
+            : null,
+        }),
+      },
+    } as unknown as AppVariables["auth"],
+  };
+}
+
+function createSetupApp(options: {
+  status: (typeof ONBOARDING_STATUS)[keyof typeof ONBOARDING_STATUS];
+  /** What `SITE_NAME` holds — null on a site nobody has named yet. */
+  storedSiteName?: string | null;
+  signedIn?: boolean;
+  isMember?: boolean;
+}) {
+  const provisionOwnerAccount = vi.fn(async () => {});
+  const completeSiteSetup = vi.fn(async () => {});
+  const updateDiscoverSetting = vi.fn(async () => ({ shouldAnnounce: false }));
+  const { auth, signUpEmail, updateUser } = createMockAuth(
+    options.signedIn ?? false,
+  );
+
+  const app = new Hono<Env>();
+  app.use("*", async (c, next) => {
+    c.env = {} as Bindings;
+    c.set("auth", auth);
+    c.set("services", {
+      settings: {
+        getOnboardingStatus: async () => options.status,
+        get: async (key: string) =>
+          key === "SITE_NAME" ? (options.storedSiteName ?? null) : null,
+        updateDiscoverSetting,
+      },
+      bootstrap: { provisionOwnerAccount, completeSiteSetup },
+      siteMembers: {
+        get: async () =>
+          options.isMember
+            ? {
+                createdAt: 0,
+                role: "owner",
+                siteId: "sit_test",
+                updatedAt: 0,
+                userId: "usr_owner",
+              }
+            : null,
+      },
+    } as unknown as AppVariables["services"]);
+    c.set("currentSite", {
+      createdAt: 0,
+      id: "sit_test",
+      key: "default",
+      status: "active",
+      updatedAt: 0,
+    });
+    c.set("appConfig", {
+      siteName: "Jant",
+      sitePathPrefix: "",
+      siteLanguage: "en",
+      demoMode: false,
+      noindex: false,
+      rssFeedsEnabled: true,
+    } as AppVariables["appConfig"]);
+    c.set("lang", "en");
+    c.set("i18n", createI18n("en"));
+    await next();
+  });
+  app.use("*", attachSession());
+  app.route("/", setupRoutes);
+
+  return {
+    app,
+    provisionOwnerAccount,
+    completeSiteSetup,
+    signUpEmail,
+    updateUser,
+  };
+}
+
+function post(app: Hono<Env>, body: Record<string, unknown>) {
+  return app.request("/setup", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+describe("GET /setup picks the step", () => {
+  it("asks an empty site for credentials, with no session needed", async () => {
+    const { app } = createSetupApp({ status: ONBOARDING_STATUS.PENDING });
+
+    const html = await (await app.request("/setup")).text();
+
+    expect(html).toContain("Setup · Step 1 of 2");
+    expect(html).toContain("setup-password");
+    expect(html).not.toContain("setup-site-name");
+  });
+
+  // The state the site rests in between the screens: an owner, and no answers.
+  it("asks a provisioned but unnamed site for its name", async () => {
+    const { app } = createSetupApp({
+      status: ONBOARDING_STATUS.PROVISIONED,
+      storedSiteName: null,
+      signedIn: true,
+      isMember: true,
+    });
+
+    const html = await (await app.request("/setup")).text();
+
+    expect(html).toContain("Setup · Step 2 of 2");
+    expect(html).toContain("setup-site-name");
+    expect(html).not.toContain("setup-password");
+  });
+
+  // The hosted arrival at the same screen. A name it already has is a question
+  // it must not be asked again.
+  it("asks a named site only what it is missing", async () => {
+    const { app } = createSetupApp({
+      status: ONBOARDING_STATUS.PROVISIONED,
+      storedSiteName: "My Blog",
+      signedIn: true,
+      isMember: true,
+    });
+
+    const html = await (await app.request("/setup")).text();
+
+    expect(html).not.toContain("setup-site-name");
+    expect(html).not.toContain("Step");
+    expect(html).toContain("setup-content-language");
+  });
+
+  it("sends a finished site home", async () => {
+    const { app } = createSetupApp({ status: ONBOARDING_STATUS.COMPLETED });
+
+    const res = await app.request("/setup", { redirect: "manual" });
+
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/");
+  });
+});
+
+describe("POST /setup, the account step", () => {
+  it("opens the account, stands the site up, and comes back for step two", async () => {
+    const { app, provisionOwnerAccount, signUpEmail } = createSetupApp({
+      status: ONBOARDING_STATUS.PENDING,
+    });
+
+    const res = await post(app, {
+      email: "  Owner@Example.COM ",
+      password: "correct-horse-battery",
+    });
+
+    // Named after the address until the next screen has a site name to put
+    // there, and normalized before it is used for either.
+    expect(signUpEmail).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: {
+          name: "owner",
+          email: "owner@example.com",
+          password: "correct-horse-battery",
+        },
+      }),
+    );
+    expect(provisionOwnerAccount).toHaveBeenCalledWith({
+      ownerUserId: "usr_new-owner",
+    });
+    await expect(res.text()).resolves.toContain("/setup");
+  });
+
+  // The whole reason there is no `/signin` hop between the screens: the second
+  // one can only be answered by a member, so the first has to leave a session
+  // behind.
+  it("signs the new owner in on the way out", async () => {
+    const { app } = createSetupApp({ status: ONBOARDING_STATUS.PENDING });
+
+    const res = await post(app, {
+      email: "owner@example.com",
+      password: "correct-horse-battery",
+    });
+
+    expect(res.headers.get("Set-Cookie")).toBe(SESSION_COOKIE);
+  });
+
+  it("rejects a password too short to be one", async () => {
+    const { app, provisionOwnerAccount } = createSetupApp({
+      status: ONBOARDING_STATUS.PENDING,
+    });
+
+    const res = await post(app, { email: "owner@example.com", password: "sh" });
+
+    await expect(res.text()).resolves.toContain("8 characters");
+    expect(provisionOwnerAccount).not.toHaveBeenCalled();
+  });
+});
+
+describe("POST /setup, the site step", () => {
+  const owner = {
+    status: ONBOARDING_STATUS.PROVISIONED,
+    storedSiteName: null,
+    signedIn: true,
+    isMember: true,
+  } as const;
+
+  it("carries the name, the language, and the browser's clock", async () => {
+    const { app, completeSiteSetup } = createSetupApp(owner);
+
+    await post(app, {
+      siteName: "My Blog",
+      contentLanguage: "zh-Hans",
+      language: "en-GB",
+      timezone: "Asia/Shanghai",
+      discover: true,
+    });
+
+    expect(completeSiteSetup).toHaveBeenCalledWith(
+      {
+        siteName: "My Blog",
+        siteLanguage: "zh-Hans",
+        browserLanguage: "en-GB",
+        timeZone: "Asia/Shanghai",
+      },
+      { oldLanguage: "en" },
+      expect.anything(),
+    );
+  });
+
+  // The rename better-auth needs, wired through the service rather than run in
+  // the route, and reaching better-auth with the request's own headers.
+  it("hands the service a way to rename the operator's account", async () => {
+    const { app, completeSiteSetup, updateUser } = createSetupApp(owner);
+
+    await post(app, { siteName: "My Blog", contentLanguage: "en" });
+
+    const deps = completeSiteSetup.mock.calls[0]?.[2] as {
+      updateCurrentUserName: (name: string) => Promise<void>;
+    };
+    await deps.updateCurrentUserName("My Blog");
+
+    expect(updateUser).toHaveBeenCalledWith(
+      expect.objectContaining({ body: { name: "My Blog" } }),
+    );
+  });
+
+  it("refuses to finish an unnamed site with no name", async () => {
+    const { app, completeSiteSetup } = createSetupApp(owner);
+
+    const res = await post(app, { contentLanguage: "en" });
+
+    await expect(res.text()).resolves.toContain("Site name");
+    expect(completeSiteSetup).not.toHaveBeenCalled();
+  });
+
+  // A named site is never asked for one, so a name arriving anyway is not the
+  // author renaming their site from the setup screen.
+  it("leaves a named site's name alone", async () => {
+    const { app, completeSiteSetup } = createSetupApp({
+      ...owner,
+      storedSiteName: "My Blog",
+    });
+
+    await post(app, { siteName: "Something Else", contentLanguage: "en" });
+
+    expect(completeSiteSetup).toHaveBeenCalledWith(
+      expect.objectContaining({ siteName: undefined, timeZone: undefined }),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+});

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

@@ -1,26 +1,72 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { createTestDatabase } from "../../../__tests__/helpers/db.js";
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../../__tests__/helpers/db.js";
 import { sql } from "drizzle-orm";
-import { navItems, settings, siteDomains, sites } from "../../../db/schema.js";
+import {
+  navItems,
+  settings,
+  siteDomains,
+  siteMembers,
+  sites,
+} from "../../../db/schema.js";
 import { createBootstrapService } from "../../../services/bootstrap.js";
+import {
+  createSiteService,
+  TRANSIENT_SINGLE_SITE_ID,
+} from "../../../services/site.js";
 import type { Database } from "../../../db/index.js";
 import type { BootstrapService } from "../../../services/bootstrap.js";
 
 /**
- * Reproduces the shell bootstrap logic from POST /setup to verify
- * setup stays idempotent even when managed shell data already exists.
+ * The bootstrap service one self-hosted setup request gets: bound to the site
+ * that request resolved, the way the runtime binds it. Resolved afresh for
+ * each screen, because the account step is what creates the site the second
+ * screen finds.
+ */
+async function bootstrapForRequest(db: Database): Promise<BootstrapService> {
+  const { site } = await createSiteService(db).resolveSingleSite();
+  return createBootstrapService(db, site.id);
+}
+
+/**
+ * Reproduces both halves of POST /setup back to back — the shape a self-hosted
+ * install ends up in — to verify setup stays idempotent even when managed shell
+ * data already exists.
  */
 async function runSetupBootstrap(
-  services: { bootstrap: BootstrapService },
-  overrides: Partial<
-    Parameters<BootstrapService["completeInitialSetup"]>[0]
-  > = {},
+  services: { db: Database },
+  overrides: Partial<Parameters<BootstrapService["completeSiteSetup"]>[0]> = {},
 ) {
-  await services.bootstrap.completeInitialSetup({
+  await (
+    await bootstrapForRequest(services.db)
+  ).provisionOwnerAccount({
     ownerUserId: "usr_test-owner",
-    siteName: "Jant Demo",
-    ...overrides,
   });
+  await (
+    await bootstrapForRequest(services.db)
+  ).completeSiteSetup(
+    { siteName: "Jant Demo", ...overrides },
+    { oldLanguage: "" },
+  );
+}
+
+/** Adds a second tenant, which is what a hosted database always has. */
+async function insertOtherSite(
+  db: Database,
+  id = "sit_other00000000000000000000",
+) {
+  const timestamp = Math.floor(Date.now() / 1000);
+  await db.insert(sites).values({
+    id,
+    key: "other",
+    status: "active",
+    createdAt: timestamp - 60,
+    updatedAt: timestamp - 60,
+  });
+  return id;
 }
 
 describe("Setup bootstrap logic", () => {
@@ -34,7 +80,8 @@ describe("Setup bootstrap logic", () => {
     const db = testDb.db as unknown as Database;
     services = {
       db,
-      bootstrap: createBootstrapService(db),
+      // The site both screens resolve once its row exists.
+      bootstrap: createBootstrapService(db, DEFAULT_TEST_SITE_ID),
     };
   });
 
@@ -46,9 +93,9 @@ describe("Setup bootstrap logic", () => {
 
     expect(navItemsList.map((item) => item.systemKey)).toEqual([
       "featured",
-      "collections",
       "archive",
-      "rss",
+      "collections",
+      "subscribe",
       "settings",
     ]);
   });
@@ -61,35 +108,150 @@ describe("Setup bootstrap logic", () => {
     expect(onboardingRow?.value).toBe("completed");
   });
 
-  it("stores the initial language, CJK font, and timezone during setup", async () => {
+  // The state the site rests in between the two setup screens. It has to be
+  // `provisioned` and not `pending`: that is what lets an author who lost the
+  // session in between sign back in and finish, rather than being bounced back
+  // to a form that would try to create their account a second time.
+  it("leaves the site provisioned and unnamed after the account step", async () => {
+    await services.bootstrap.provisionOwnerAccount({
+      ownerUserId: "usr_test-owner",
+    });
+
+    const rows = await services.db.select().from(settings);
+    expect(rows.find((row) => row.key === "ONBOARDING_STATUS")?.value).toBe(
+      "provisioned",
+    );
+    expect(rows.find((row) => row.key === "SITE_NAME")).toBeUndefined();
+
+    const navItemsList = await services.db.select().from(navItems);
+    expect(navItemsList).toHaveLength(5);
+  });
+
+  // The hosted path through the same method: the control plane named the site
+  // at creation, and the author answering the last screen must not blank it.
+  it("leaves an existing name alone when the last screen asked for none", async () => {
+    await runSetupBootstrap(services);
+    await services.bootstrap.completeSiteSetup(
+      { siteLanguage: "en" },
+      { oldLanguage: "en" },
+    );
+
+    const rows = await services.db.select().from(settings);
+    expect(rows.find((row) => row.key === "SITE_NAME")?.value).toBe(
+      "Jant Demo",
+    );
+  });
+
+  it("renames the operator's account to match the site", async () => {
+    const updateCurrentUserName = vi.fn(async () => undefined);
+
+    await services.bootstrap.provisionOwnerAccount({
+      ownerUserId: "usr_test-owner",
+    });
+    await services.bootstrap.completeSiteSetup(
+      { siteName: "  Jant Demo  " },
+      { oldLanguage: "" },
+      { updateCurrentUserName },
+    );
+
+    expect(updateCurrentUserName).toHaveBeenCalledWith("Jant Demo");
+  });
+
+  // The rename runs before onboarding closes, so a better-auth failure leaves
+  // the author on the screen they were already on instead of inside a finished
+  // site under a stale account name.
+  it("leaves setup open when the account rename fails", async () => {
+    await services.bootstrap.provisionOwnerAccount({
+      ownerUserId: "usr_test-owner",
+    });
+    await expect(
+      services.bootstrap.completeSiteSetup(
+        { siteName: "Jant Demo" },
+        { oldLanguage: "" },
+        {
+          updateCurrentUserName: async () => {
+            throw new Error("better-auth unavailable");
+          },
+        },
+      ),
+    ).rejects.toThrow("better-auth unavailable");
+
+    const rows = await services.db.select().from(settings);
+    expect(rows.find((row) => row.key === "ONBOARDING_STATUS")?.value).toBe(
+      "provisioned",
+    );
+  });
+
+  it("stores the chosen content language and timezone during setup", async () => {
     await runSetupBootstrap(services, {
       siteLanguage: "en",
-      cjkSerifFont: "zh-Hans",
       timeZone: "Asia/Shanghai",
     });
 
     const rows = await services.db.select().from(settings);
     expect(rows.find((row) => row.key === "SITE_LANGUAGE")?.value).toBe("en");
-    expect(rows.find((row) => row.key === "CJK_SERIF_FONT")?.value).toBe(
-      "zh-Hans",
-    );
     expect(rows.find((row) => row.key === "TIME_ZONE")?.value).toBe(
       "Asia/Shanghai",
     );
   });
 
-  it("pins the dashboard language to the detected catalog locale", async () => {
+  it("pins the dashboard language when only the browser knows it", async () => {
+    // Someone running an English blog from a Chinese browser: English site,
+    // Chinese dashboard. Following the content language would miss this.
+    await runSetupBootstrap(services, {
+      siteLanguage: "en",
+      browserLanguage: "zh-TW",
+    });
+
+    const rows = await services.db.select().from(settings);
+    expect(rows.find((row) => row.key === "SITE_LANGUAGE")?.value).toBe("en");
+    expect(rows.find((row) => row.key === "DASHBOARD_LANGUAGE")?.value).toBe(
+      "zh-Hant",
+    );
+  });
+
+  it("leaves the dashboard following a content language the author chose", async () => {
+    // The reverse mismatch, and the common one: an English browser is what
+    // every unconfigured machine reports, so it is no evidence against the
+    // language just chosen by hand. The dashboard must not freeze to English.
+    await runSetupBootstrap(services, {
+      siteLanguage: "zh-Hans",
+      browserLanguage: "en",
+    });
+
+    const rows = await services.db.select().from(settings);
+    expect(rows.find((row) => row.key === "SITE_LANGUAGE")?.value).toBe(
+      "zh-Hans",
+    );
+    expect(
+      rows.find((row) => row.key === "DASHBOARD_LANGUAGE"),
+    ).toBeUndefined();
+  });
+
+  it("leaves the dashboard following when the browser sent none", async () => {
     await runSetupBootstrap(services, { siteLanguage: "zh-TW" });
 
     const rows = await services.db.select().from(settings);
-    // Content language stays verbatim; the dashboard locale is the resolved
-    // catalog (zh-Hant) so it is stable if content language later changes.
+    // Content language stays verbatim, and the dashboard derives zh-Hant from
+    // it at render time rather than being pinned here.
     expect(rows.find((row) => row.key === "SITE_LANGUAGE")?.value).toBe(
       "zh-TW",
     );
-    expect(rows.find((row) => row.key === "DASHBOARD_LANGUAGE")?.value).toBe(
-      "zh-Hant",
-    );
+    expect(
+      rows.find((row) => row.key === "DASHBOARD_LANGUAGE"),
+    ).toBeUndefined();
+  });
+
+  it("leaves the dashboard following when browser and content agree", async () => {
+    await runSetupBootstrap(services, {
+      siteLanguage: "zh-Hans",
+      browserLanguage: "zh-CN",
+    });
+
+    const rows = await services.db.select().from(settings);
+    expect(
+      rows.find((row) => row.key === "DASHBOARD_LANGUAGE"),
+    ).toBeUndefined();
   });
 
   it("is idempotent when default navigation already exists", async () => {
@@ -141,5 +303,95 @@ describe("Setup bootstrap logic", () => {
     const domainRows = await services.db.select().from(siteDomains);
     expect(siteRows).toHaveLength(1);
     expect(domainRows).toHaveLength(0);
+
+    const rows = await services.db.select().from(settings);
+    expect(rows.find((row) => row.key === "SITE_NAME")?.siteId).toBe(
+      siteRows[0]?.id,
+    );
+  });
+
+  // Settings written under the placeholder would belong to no site at all.
+  it("refuses to finish a site the account step has not created", async () => {
+    await services.db.run(sql`DELETE FROM "site"`);
+
+    await expect(
+      createBootstrapService(
+        services.db,
+        TRANSIENT_SINGLE_SITE_ID,
+      ).completeSiteSetup({ siteName: "Jant Demo" }, { oldLanguage: "" }),
+    ).rejects.toThrow("completeSiteSetup needs an existing site");
+
+    expect(await services.db.select().from(settings)).toHaveLength(0);
+  });
+});
+
+// A hosted database holds every tenant, so "the only site" has no answer there.
+// Setup's last screen must write to the site the request's host resolved — the
+// one the route's membership check just read — and leave every other tenant
+// alone. The account screen has no hosted use at all.
+describe("Setup bootstrap on a host-based install", () => {
+  function createHostedServices() {
+    const { services, db } = createTestApp({
+      siteResolutionMode: "host-based",
+    });
+    return { services, db };
+  }
+
+  it("finishes the request's site while other sites share the database", async () => {
+    const { services, db } = createHostedServices();
+    const otherSiteId = await insertOtherSite(db);
+
+    await services.bootstrap.completeSiteSetup(
+      { siteLanguage: "en" },
+      { oldLanguage: "" },
+    );
+
+    const rows = await db.select().from(settings);
+    expect(
+      rows.find(
+        (row) =>
+          row.siteId === DEFAULT_TEST_SITE_ID &&
+          row.key === "ONBOARDING_STATUS",
+      )?.value,
+    ).toBe("completed");
+    expect(rows.filter((row) => row.siteId === otherSiteId)).toHaveLength(0);
+  });
+
+  // A hosted site's owner arrives through the control plane's handoff. The
+  // account step would make whoever signed in the owner of the site the host
+  // resolved, so it refuses before writing anything to any tenant.
+  it("refuses the account step and writes nothing", async () => {
+    const { services, db } = createHostedServices();
+    await insertOtherSite(db);
+
+    await expect(
+      services.bootstrap.provisionOwnerAccount({
+        ownerUserId: "usr_test-owner",
+      }),
+    ).rejects.toThrow(
+      "provisionOwnerAccount runs on self-hosted installs only",
+    );
+
+    expect(await db.select().from(sites)).toHaveLength(2);
+    expect(await db.select().from(siteMembers)).toHaveLength(0);
+    expect(await db.select().from(navItems)).toHaveLength(0);
+    expect(await db.select().from(settings)).toHaveLength(0);
+  });
+
+  // The control plane creates hosted sites. Materializing one here would add a
+  // stray tenant to a database that holds real ones.
+  it("never creates a site when the request resolved none", async () => {
+    const db = createTestDatabase().db as unknown as Database;
+    await db.run(sql`DELETE FROM "site"`);
+
+    await expect(
+      createBootstrapService(db, TRANSIENT_SINGLE_SITE_ID, {
+        siteResolutionMode: "host-based",
+      }).provisionOwnerAccount({ ownerUserId: "usr_test-owner" }),
+    ).rejects.toThrow(
+      "provisionOwnerAccount runs on self-hosted installs only",
+    );
+
+    expect(await db.select().from(sites)).toHaveLength(0);
   });
 });