@jant/core 0.6.16 → 0.7.0

package/src/node/__tests__/cli-reset-password.test.ts

@@ -7,17 +7,23 @@ import { run } from "../../../bin/commands/reset-password.js";
 import { migrate } from "../runtime.js";
 import type { Bindings } from "../../types.js";
 import { createBootstrapService } from "../../services/bootstrap.js";
+import { createSiteService } from "../../services/site.js";
 import { createNodeDatabase } from "../../db/index.js";
 
 describe("jant reset-password", () => {
   const tempDirs: string[] = [];
-  const originalEnv = process.env.DATABASE_URL;
+  const originalEnv = {
+    DATABASE_URL: process.env.DATABASE_URL,
+    SITE_RESOLUTION_MODE: process.env.SITE_RESOLUTION_MODE,
+  };
 
   afterEach(async () => {
-    if (originalEnv === undefined) {
-      delete process.env.DATABASE_URL;
-    } else {
-      process.env.DATABASE_URL = originalEnv;
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
     }
 
     await Promise.all(
@@ -37,7 +43,14 @@ describe("jant reset-password", () => {
 
     const sqlite = new Database(databasePath);
     try {
-      const bootstrap = createBootstrapService(createNodeDatabase(sqlite));
+      const db = createNodeDatabase(sqlite);
+      // Each setup screen is its own request, bound to the site it resolved:
+      // none before the account step, the one it created after.
+      const bootstrapForRequest = async () =>
+        createBootstrapService(
+          db,
+          (await createSiteService(db).resolveSingleSite()).site.id,
+        );
       await sqlite
         .prepare(
           `
@@ -53,10 +66,17 @@ describe("jant reset-password", () => {
           new Date().toISOString(),
           new Date().toISOString(),
         );
-      await bootstrap.completeInitialSetup({
+      await (
+        await bootstrapForRequest()
+      ).provisionOwnerAccount({
         ownerUserId: "usr_reset_password_test",
-        siteName: "Reset Password Test",
       });
+      await (
+        await bootstrapForRequest()
+      ).completeSiteSetup(
+        { siteName: "Reset Password Test" },
+        { oldLanguage: "" },
+      );
     } finally {
       sqlite.close();
     }
@@ -88,4 +108,57 @@ describe("jant reset-password", () => {
       expect.stringMatching(/^Visit: \/reset\?token=[a-f0-9]{64}$/),
     );
   });
+
+  // A hosted database holds every tenant, so the token goes to the site the
+  // operator named — and nowhere when they named none.
+  it("writes the token to the site --site names on a host-based database", async () => {
+    const root = await mkdtemp(join(tmpdir(), "jant-reset-password-hosted-"));
+    tempDirs.push(root);
+
+    const databasePath = join(root, "jant.sqlite");
+    await migrate({ DATABASE_URL: `file:${databasePath}` } as Bindings);
+    process.env.DATABASE_URL = `file:${databasePath}`;
+    process.env.SITE_RESOLUTION_MODE = "host-based";
+
+    const sqlite = new Database(databasePath);
+    try {
+      sqlite
+        .prepare(
+          `
+            INSERT INTO site (id, key, status, created_at, updated_at)
+            VALUES
+              ('sit_alpha000000000000000000000', 'alpha', 'active', 1774200000, 1774200000),
+              ('sit_beta0000000000000000000000', 'beta', 'active', 1774200001, 1774200001)
+          `,
+        )
+        .run();
+    } finally {
+      sqlite.close();
+    }
+
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(run([])).rejects.toThrow(
+      "host-based mode needs a target site. Pass --site <key|id>, --host <host>, or --url <url>.",
+    );
+    await run(["--site", "beta"]);
+
+    const sqliteReadonly = new Database(databasePath, { readonly: true });
+    try {
+      const owners = sqliteReadonly
+        .prepare(
+          `
+            SELECT site_id
+            FROM "site_setting"
+            WHERE "key" = 'PASSWORD_RESET_TOKEN'
+          `,
+        )
+        .pluck()
+        .all();
+
+      expect(owners).toEqual(["sit_beta0000000000000000000000"]);
+    } finally {
+      sqliteReadonly.close();
+    }
+  });
 });

package/src/node/__tests__/cli-runtime-target.test.ts

@@ -2,7 +2,7 @@ import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { loadNodeEnvFile } from "../../../bin/lib/node-env.js";
+import { findNodeEnvPath, loadNodeEnvFile } from "../../../bin/lib/node-env.js";
 import {
   formatRuntimeBanner,
   resolveCliRuntime,
@@ -106,6 +106,53 @@ describe("loadNodeEnvFile", () => {
   });
 });
 
+describe("findNodeEnvPath", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "jant-env-path-"));
+  });
+
+  it("finds .env.node in the given directory when JANT_ENV_FILE is unset", () => {
+    const envPath = join(tmpDir, ".env.node");
+    writeFileSync(envPath, "DATABASE_URL=file:./jant.sqlite\n");
+
+    expect(findNodeEnvPath(tmpDir, {})).toBe(envPath);
+  });
+
+  it("loads nothing when JANT_ENV_FILE is empty", () => {
+    writeFileSync(
+      join(tmpDir, ".env.node"),
+      "DATABASE_URL=file:./local.sqlite\n",
+    );
+
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "" })).toBeNull();
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "  " })).toBeNull();
+  });
+
+  it("uses the file JANT_ENV_FILE names, resolved against the directory", () => {
+    writeFileSync(
+      join(tmpDir, ".env.node"),
+      "DATABASE_URL=file:./local.sqlite\n",
+    );
+    const overridePath = join(tmpDir, "staging.env");
+    writeFileSync(overridePath, "DATABASE_URL=postgres://example/db\n");
+
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "staging.env" })).toBe(
+      overridePath,
+    );
+    expect(findNodeEnvPath(tmpDir, { JANT_ENV_FILE: overridePath })).toBe(
+      overridePath,
+    );
+  });
+
+  it("throws when JANT_ENV_FILE names a file that does not exist", () => {
+    expect(() =>
+      findNodeEnvPath(tmpDir, { JANT_ENV_FILE: "missing.env" }),
+    ).toThrow(/JANT_ENV_FILE points at "missing.env"/);
+  });
+});
+
 describe("formatRuntimeBanner", () => {
   const originalLog = console.log;
   beforeEach(() => {

package/src/node/__tests__/cli-site-selection.test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it, vi } from "vitest";
-import { resolveCliSite } from "../../../bin/lib/site-selection.js";
+import {
+  parseCliSiteSelector,
+  resolveCliSite,
+} from "../../../bin/lib/site-selection.js";
 
 function createSiteRow(id, key) {
   return {
@@ -11,6 +14,8 @@ function createSiteRow(id, key) {
   };
 }
 
+const HOST_BASED_ENV = { SITE_RESOLUTION_MODE: "host-based" };
+
 describe("CLI site selection", () => {
   it("resolves a host-scoped site in host-based mode", async () => {
     const query = vi.fn(async (sql) => {
@@ -26,9 +31,7 @@ describe("CLI site selection", () => {
         query,
       },
       {
-        env: {
-          SITE_RESOLUTION_MODE: "host-based",
-        },
+        env: HOST_BASED_ENV,
         host: "demo.jant.blog",
       },
     );
@@ -54,9 +57,7 @@ describe("CLI site selection", () => {
         query,
       },
       {
-        env: {
-          SITE_RESOLUTION_MODE: "host-based",
-        },
+        env: HOST_BASED_ENV,
         url: "https://demo.jant.blog/base/",
       },
     );
@@ -64,49 +65,91 @@ describe("CLI site selection", () => {
     expect(resolved.site.key).toBe("demo");
   });
 
-  it("falls back to the only site in host-based mode", async () => {
-    const query = vi.fn(async (sql) => {
-      if (sql.includes('FROM "site_domain"')) {
-        return [];
-      }
-
-      return [createSiteRow("sit_only", "only")];
-    });
+  it("resolves --site by key or by id", async () => {
+    const sites = [
+      createSiteRow("sit_one", "one"),
+      createSiteRow("sit_two", "two"),
+    ];
+    const query = vi.fn(async (sql) =>
+      sites.filter(
+        (site) =>
+          sql.includes(`"id" = '${site.id}'`) ||
+          sql.includes(`"key" = '${site.key}'`),
+      ),
+    );
 
-    const resolved = await resolveCliSite(
-      {
-        query,
-      },
-      {
-        env: {
-          SITE_RESOLUTION_MODE: "host-based",
-        },
-      },
+    const byKey = await resolveCliSite(
+      { query },
+      { env: HOST_BASED_ENV, site: "two" },
+    );
+    const byId = await resolveCliSite(
+      { query },
+      { env: HOST_BASED_ENV, site: "sit_one" },
     );
 
-    expect(resolved.site.id).toBe("sit_only");
+    expect(byKey.site.id).toBe("sit_two");
+    expect(byId.site.id).toBe("sit_one");
   });
 
-  it("requires explicit selection for host-based multi-site instances", async () => {
+  // Unreachable through the managed API, whose keys cannot contain `_`, but a
+  // hand-edited row must not make `--site` pick a tenant by accident.
+  it("prefers the id match when a key equals another site's id", async () => {
     const query = vi.fn(async () => [
-      createSiteRow("sit_one", "one"),
-      createSiteRow("sit_two", "two"),
+      createSiteRow("sit_other", "sit_target"),
+      createSiteRow("sit_target", "target"),
     ]);
 
+    const resolved = await resolveCliSite(
+      { query },
+      { env: HOST_BASED_ENV, site: "sit_target" },
+    );
+
+    expect(resolved.site.key).toBe("target");
+  });
+
+  it("names the --site value that matched nothing", async () => {
+    const query = vi.fn(async () => []);
+
+    await expect(
+      resolveCliSite({ query }, { env: HOST_BASED_ENV, site: "missing" }),
+    ).rejects.toThrow("No site found for --site missing.");
+  });
+
+  // A hosted database holds every tenant. Falling back to "the only site"
+  // would work until the day a second tenant signs up, so host-based mode
+  // never guesses — it fails before running a single query.
+  it("requires a site flag in host-based mode, however many sites exist", async () => {
+    const query = vi.fn(async () => [createSiteRow("sit_only", "only")]);
+
+    await expect(
+      resolveCliSite({ query }, { env: HOST_BASED_ENV }),
+    ).rejects.toThrow(
+      "host-based mode needs a target site. Pass --site <key|id>, --host <host>, or --url <url>.",
+    );
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it("rejects more than one site flag instead of picking one", async () => {
+    const query = vi.fn(async () => []);
+
     await expect(
       resolveCliSite(
-        {
-          query,
-        },
-        {
-          env: {
-            SITE_RESOLUTION_MODE: "host-based",
-          },
-        },
+        { query },
+        { env: HOST_BASED_ENV, site: "one", host: "two.jant.blog" },
       ),
-    ).rejects.toThrow(
-      "host-based mode requires --site, --host, or --url when the database contains multiple sites.",
+    ).rejects.toThrow("Choose only one of --site, --host, or --url.");
+    expect(query).not.toHaveBeenCalled();
+  });
+
+  it("uses the only site in single-site mode", async () => {
+    const query = vi.fn(async () => [createSiteRow("sit_only", "only")]);
+
+    const resolved = await resolveCliSite(
+      { query },
+      { env: { SITE_RESOLUTION_MODE: "single-site" } },
     );
+
+    expect(resolved.site.id).toBe("sit_only");
   });
 
   it("returns an actionable message for single-site multi-site instances", async () => {
@@ -131,3 +174,50 @@ describe("CLI site selection", () => {
     );
   });
 });
+
+describe("parseCliSiteSelector", () => {
+  it("returns null when no site flag was passed", () => {
+    expect(parseCliSiteSelector({ pathPrefix: "/blog" })).toBeNull();
+  });
+
+  it("reads --site as a key or id", () => {
+    expect(parseCliSiteSelector({ site: " demo " })).toEqual({
+      kind: "site",
+      idOrKey: "demo",
+    });
+  });
+
+  it("splits --url into its host and path prefix", () => {
+    expect(parseCliSiteSelector({ url: "https://demo.jant.blog/" })).toEqual({
+      kind: "host",
+      host: "demo.jant.blog",
+      pathPrefix: null,
+    });
+    expect(
+      parseCliSiteSelector({ url: "https://demo.jant.blog/blog/" }),
+    ).toEqual({
+      kind: "host",
+      host: "demo.jant.blog",
+      pathPrefix: "/blog",
+    });
+  });
+
+  it("pairs --host with --path-prefix", () => {
+    expect(
+      parseCliSiteSelector({ host: "demo.jant.blog", pathPrefix: "blog/" }),
+    ).toEqual({
+      kind: "host",
+      host: "demo.jant.blog",
+      pathPrefix: "/blog",
+    });
+  });
+
+  it("rejects --url together with --host", () => {
+    expect(() =>
+      parseCliSiteSelector({
+        host: "demo.jant.blog",
+        url: "https://demo.jant.blog/",
+      }),
+    ).toThrow("Choose only one of --site, --host, or --url.");
+  });
+});

package/src/node/__tests__/runtime.test.ts

@@ -204,6 +204,43 @@ describe("resolveNodeAssetRoot", () => {
     ).rejects.toThrow("single-site mode found multiple sites in the database:");
   });
 
+  // The single-site readiness check blames SITE_RESOLUTION_MODE for extra
+  // sites, which on a hosted database are just its tenants.
+  it("starts in host-based mode when the database holds several sites", async () => {
+    const root = await mkdtemp(join(tmpdir(), "jant-node-host-based-sites-"));
+    tempDirs.push(root);
+    const databasePath = join(root, "data", "jant.sqlite");
+
+    await migrate({
+      DATABASE_URL: `file:${databasePath}`,
+    } as Bindings);
+
+    const sqlite = new Database(databasePath);
+    try {
+      sqlite
+        .prepare(
+          `
+            INSERT INTO site (id, key, status, created_at, updated_at)
+            VALUES
+              ('sit_primary00000000000000000000', 'primary', 'active', 1774200000, 1774200000),
+              ('sit_extra000000000000000000000', 'extra', 'active', 1774200001, 1774200001)
+          `,
+        )
+        .run();
+    } finally {
+      sqlite.close();
+    }
+
+    const handler = await createNodeRequestHandler({
+      assetRoot: null,
+      env: {
+        DATABASE_URL: `file:${databasePath}`,
+        ...VALID_HOST_BASED_NODE_ENV,
+      } as Bindings,
+    });
+    await handler.close();
+  });
+
   it("fails fast when host-based mode is missing hosted control-plane config", async () => {
     const root = await mkdtemp(join(tmpdir(), "jant-node-host-based-config-"));
     tempDirs.push(root);

package/src/node/index.ts

@@ -7,6 +7,7 @@ export {
   createNodeCliRuntime,
   createNodeRequestRuntime,
 } from "../runtime/node.js";
+export type { CliSiteSelector } from "../runtime/site.js";
 export { createExportService } from "../services/export.js";
 export { createStorageDriver } from "../lib/storage.js";
 export { resolveConfig } from "../lib/resolve-config.js";

package/src/preset.css

@@ -55,6 +55,9 @@ html {
  * text when a serif font theme is active (Tufte, Bookish, etc.).
  */
 @layer components {
+  /* Every BaseCoat button variant, not only the default size: a
+     `btn-sm-outline` is as much a UI control as a `btn-outline`, and one left
+     off this list silently picks up the theme's content font instead. */
   .btn,
   .btn-primary,
   .btn-secondary,
@@ -62,6 +65,41 @@ html {
   .btn-ghost,
   .btn-link,
   .btn-destructive,
+  .btn-sm,
+  .btn-sm-primary,
+  .btn-sm-secondary,
+  .btn-sm-outline,
+  .btn-sm-ghost,
+  .btn-sm-link,
+  .btn-sm-destructive,
+  .btn-lg,
+  .btn-lg-primary,
+  .btn-lg-secondary,
+  .btn-lg-outline,
+  .btn-lg-ghost,
+  .btn-lg-link,
+  .btn-lg-destructive,
+  .btn-icon,
+  .btn-icon-primary,
+  .btn-icon-secondary,
+  .btn-icon-outline,
+  .btn-icon-ghost,
+  .btn-icon-link,
+  .btn-icon-destructive,
+  .btn-sm-icon,
+  .btn-sm-icon-primary,
+  .btn-sm-icon-secondary,
+  .btn-sm-icon-outline,
+  .btn-sm-icon-ghost,
+  .btn-sm-icon-link,
+  .btn-sm-icon-destructive,
+  .btn-lg-icon,
+  .btn-lg-icon-primary,
+  .btn-lg-icon-secondary,
+  .btn-lg-icon-outline,
+  .btn-lg-icon-ghost,
+  .btn-lg-icon-link,
+  .btn-lg-icon-destructive,
   .badge,
   .badge-primary,
   .badge-secondary,
@@ -191,6 +229,12 @@ html {
   font-size: var(--type-body-size);
   line-height: var(--type-body-leading);
   letter-spacing: var(--type-body-tracking);
+  /* Authored text can contain a run with no break opportunity — a long URL, an
+     ID, a word typed without spaces. Such a run does not wrap on its own and
+     spills past the content column across the page. `break-word` splits it only
+     when it cannot fit a line by itself, so ordinary text keeps its natural
+     line breaks and intrinsic sizing is unaffected. */
+  overflow-wrap: break-word;
 
   :where(h1, h2, h3, h4, h5, h6) {
     font-family: var(--font-heading);
@@ -529,6 +573,30 @@ html {
   );
 }
 
+/*
+ * Author text outside `.prose`
+ *
+ * Titles, quote bodies, and their attributions render authored text without
+ * the prose wrapper, so they need the same last-resort break. Without it a
+ * single unbroken run overflows the fixed-width content column below.
+ */
+.post-detail-title,
+.post-detail-quote,
+.feed-note-title,
+.feed-link-title,
+.feed-quote-content {
+  overflow-wrap: break-word;
+}
+
+/* Attribution and domain lay their parts out with flex, so each part is a flex
+   item that refuses to shrink below its min-content width. `break-word` leaves
+   min-content at the longest word and the item still overflows; `anywhere` also
+   shrinks min-content, which is what lets the row wrap. */
+.feed-quote-attribution,
+.feed-link-domain {
+  overflow-wrap: anywhere;
+}
+
 /*
  * Tufte content-width constraint.
  *
@@ -554,7 +622,7 @@ html {
 [data-post-body].prose,
 [data-post-meta],
 [data-post-end] {
-  width: var(--layout-content-width);
+  width: var(--layout-reading-width);
 }
 
 .post-detail-title {
@@ -571,7 +639,7 @@ html {
    actions follow the gallery's right edge. */
 .post-attached-group {
   width: fit-content;
-  min-width: var(--layout-content-width);
+  min-width: var(--layout-reading-width);
   max-width: 100%;
 }
 
@@ -579,26 +647,12 @@ html {
   width: 100%;
 }
 
+/* Everything above already tracks the reading column through the token; only
+   the title needs saying twice, because its desktop measure is narrower than
+   the column (Tufte sets titles short) and there is no gutter left to keep it
+   short for down here. */
 @media (max-width: 1024px) {
-  [data-page="search"],
-  .site-home-header,
-  .post-detail-title,
-  .post-detail-body,
-  .post-body-summary,
-  .feed-note-title,
-  .feed-link-title,
-  .feed-quote,
-  .feed-quote-attribution,
-  .feed-quote-commentary,
-  .feed-link-domain,
-  .feed-continue-link,
-  [data-post-body].prose,
-  [data-post-meta],
-  [data-post-end] {
-    width: min(100%, 35rem);
-  }
-
-  .post-attached-group {
-    min-width: min(100%, 35rem);
+  .post-detail-title {
+    width: var(--layout-reading-width);
   }
 }