@jant/core 0.6.16 → 0.7.0

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

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

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { Hono } from "hono";
+import { createI18n } from "../../../i18n/index.js";
+import { attachSession } from "../../../middleware/session.js";
+import { requireAuth } from "../../../middleware/auth.js";
+import { signinRoutes } from "../signin.js";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+const SIGNIN_FORM_MARKER = 'data-bind="password"';
+
+/**
+ * A session for `usr_stale` that the site knows nothing about — what a browser
+ * still holds right after a factory reset, since better-auth answers from its
+ * cookie cache for minutes after the rows are gone.
+ */
+function createMockAuth(signedIn: boolean) {
+  return {
+    api: {
+      getSession: async () => ({
+        headers: new Headers(),
+        response: signedIn
+          ? {
+              user: { id: "usr_stale", email: "old@test.com", name: "Old" },
+              session: { id: "ses_stale" },
+            }
+          : null,
+      }),
+    },
+  } as unknown as AppVariables["auth"];
+}
+
+function createMockServices(isMember: boolean) {
+  return {
+    siteMembers: {
+      get: async () =>
+        isMember
+          ? {
+              createdAt: 0,
+              role: "owner",
+              siteId: "sit_test",
+              updatedAt: 0,
+              userId: "usr_stale",
+            }
+          : null,
+    },
+  } as unknown as AppVariables["services"];
+}
+
+function createSigninTestApp(options: {
+  signedIn: boolean;
+  isMember: boolean;
+}) {
+  const app = new Hono<Env>();
+  app.use("*", async (c, next) => {
+    c.env = {} as Bindings;
+    c.set("auth", createMockAuth(options.signedIn));
+    c.set("services", createMockServices(options.isMember));
+    c.set("currentSite", {
+      createdAt: 0,
+      id: "sit_test",
+      key: "default",
+      status: "active",
+      updatedAt: 0,
+    });
+    c.set("currentSiteDomain", null);
+    c.set("appConfig", {
+      siteName: "Jant",
+      sitePathPrefix: "",
+    } as AppVariables["appConfig"]);
+    c.set("publicRequestUrl", "http://localhost/signin");
+    c.set("lang", "en");
+    c.set("i18n", createI18n("en"));
+    await next();
+  });
+  app.use("*", attachSession());
+  app.route("/", signinRoutes);
+  app.use("/settings", requireAuth());
+  app.get("/settings", (c) => c.text("Settings"));
+  return app;
+}
+
+describe("GET /signin", () => {
+  it("shows the form to a session that is not a member of this site", async () => {
+    const app = createSigninTestApp({ signedIn: true, isMember: false });
+
+    const res = await app.request("/signin?redirect=%2Fsettings", {
+      redirect: "manual",
+    });
+
+    expect(res.status).toBe(200);
+    expect(await res.text()).toContain(SIGNIN_FORM_MARKER);
+  });
+
+  it("sends a member on to where they were headed", async () => {
+    const app = createSigninTestApp({ signedIn: true, isMember: true });
+
+    const res = await app.request("/signin?redirect=%2Fsettings", {
+      redirect: "manual",
+    });
+
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/settings");
+  });
+
+  it("still shows the form to a visitor with no session", async () => {
+    const app = createSigninTestApp({ signedIn: false, isMember: false });
+
+    const res = await app.request("/signin", { redirect: "manual" });
+
+    expect(res.status).toBe(200);
+    expect(await res.text()).toContain(SIGNIN_FORM_MARKER);
+  });
+});
+
+describe("stale session redirect loop", () => {
+  it("lands on the sign-in form instead of volleying with /settings", async () => {
+    const app = createSigninTestApp({ signedIn: true, isMember: false });
+
+    // `requireAuth` requires membership, so a session left over from a deleted
+    // site is turned away here.
+    const guarded = await app.request("/settings", { redirect: "manual" });
+    expect(guarded.status).toBe(302);
+    const signinLocation = guarded.headers.get("Location");
+    expect(signinLocation).toBe("/signin?redirect=%2Fsettings");
+
+    // …and this is the hop that used to send the same session straight back to
+    // /settings, three redirects per lap until the browser gave up.
+    const signin = await app.request(signinLocation!, { redirect: "manual" });
+    expect(signin.status).toBe(200);
+    expect(await signin.text()).toContain(SIGNIN_FORM_MARKER);
+  });
+});