@jant/core 0.6.16 → 0.7.1

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

@@ -12,6 +12,7 @@ import {
   resolveDatabasePath,
   resolvePublicRequestUrl,
 } from "../runtime.js";
+import type { App } from "../../types/app-context.js";
 import type { Bindings } from "../../types.js";
 
 const tempDirs: string[] = [];
@@ -204,6 +205,80 @@ describe("resolveNodeAssetRoot", () => {
     ).rejects.toThrow("single-site mode found multiple sites in the database:");
   });
 
+  // A deploy check tells a container that just started from one a rollback
+  // left running by this stamp, so it has to be the handler's start and not a
+  // time taken per request.
+  it("stamps the bindings with when the handler started serving", async () => {
+    const root = await mkdtemp(join(tmpdir(), "jant-node-started-at-"));
+    tempDirs.push(root);
+    const databasePath = join(root, "data", "jant.sqlite");
+    await migrate({ DATABASE_URL: `file:${databasePath}` } as Bindings);
+
+    const before = Math.floor(Date.now() / 1000);
+    const handler = await createNodeRequestHandler({
+      assetRoot: null,
+      env: { DATABASE_URL: `file:${databasePath}` } as Bindings,
+      app: {
+        fetch: (_request: Request, env: Bindings) =>
+          Response.json({ startedAt: env.NODE_STARTED_AT }),
+      } as unknown as App,
+    });
+    const after = Math.floor(Date.now() / 1000);
+
+    try {
+      const read = async () =>
+        (
+          (await (
+            await handler.fetch(new Request("http://127.0.0.1:3000/readyz"))
+          ).json()) as { startedAt: number }
+        ).startedAt;
+      const first = await read();
+
+      expect(first).toBeGreaterThanOrEqual(before);
+      expect(first).toBeLessThanOrEqual(after);
+      expect(await read()).toBe(first);
+    } finally {
+      await handler.close();
+    }
+  });
+
+  // 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

@@ -6,9 +6,12 @@ export { createNodeRequestHandler } from "./request-handler.js";
 export {
   createNodeCliRuntime,
   createNodeRequestRuntime,
+  setUpNodeInstance,
 } from "../runtime/node.js";
+export type { CliSiteSelector } from "../runtime/site.js";
 export { createExportService } from "../services/export.js";
 export { createStorageDriver } from "../lib/storage.js";
+export { getConfiguredStorageDriver } from "../lib/env.js";
 export { resolveConfig } from "../lib/resolve-config.js";
 export { buildThemeStyle } from "../lib/theme.js";
 export { BUILTIN_COLOR_THEMES } from "../ui/color-themes.js";

package/src/node/request-handler.ts

@@ -31,6 +31,7 @@ import {
   shouldTrustProxy,
 } from "../lib/env.js";
 import { getHostBasedStartupConfigurationIssues } from "../lib/startup-config.js";
+import { now } from "../lib/time.js";
 import { createSiteService } from "../services/site.js";
 import type { App } from "../types/app-context.js";
 import type { Bindings } from "../types/bindings.js";
@@ -616,7 +617,8 @@ export async function createNodeRequestHandler(options?: {
       `Host-based startup configuration is invalid:\n- ${hostBasedStartupIssues.map((issue) => issue.message).join("\n- ")}`,
     );
   }
-  const { bindings, close } = await createNodeBindings(env);
+  const { bindings: databaseBindings, close } = await createNodeBindings(env);
+  const bindings: Bindings = { ...databaseBindings, NODE_STARTED_AT: now() };
   try {
     await assertNodeSiteResolutionReady(bindings);
 

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

package/src/routes/__tests__/feed-validator.test.ts

@@ -0,0 +1,156 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { createTestApp } from "../../__tests__/helpers/app.js";
+import { archiveRoutes } from "../pages/archive.js";
+import { collectionRoutes } from "../pages/collection.js";
+import { collectionsPageRoutes } from "../pages/collections.js";
+import { featuredRoutes } from "../pages/featured.js";
+import { latestRoutes } from "../pages/latest.js";
+import { pageRoutes } from "../pages/page.js";
+import { feedRoutes } from "../feed/feed.js";
+
+/**
+ * The validator every feed surface carries.
+ *
+ * Six route modules assemble a feed, and each used to build its own Response.
+ * They now share `renderFeed`, so what these tests hold in place is that the
+ * sharing is real — a tag on every feed, not just on `/feed`, whose tests are
+ * the ones anyone remembers to run.
+ *
+ * Turning that tag into a `304` belongs to `withConditionalResponse` at the
+ * edge of the app, and is covered where it lives.
+ */
+
+const ETAG = /^"[0-9a-f]{32}"$/;
+
+function setup() {
+  const testApp = createTestApp({ rssPublishDelaySeconds: 0 });
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+
+  app.route("/feed", feedRoutes);
+  app.route("/latest", latestRoutes);
+  app.route("/featured", featuredRoutes);
+  app.route("/archive", archiveRoutes);
+  app.route("/collections", collectionsPageRoutes);
+  app.route("/collections", collectionRoutes);
+  // The root namespace matches any slug, so it is mounted last.
+  app.route("/", pageRoutes);
+
+  return testApp;
+}
+
+/**
+ * Seed every surface with an entry.
+ *
+ * An empty feed has no content timestamp to date itself by and falls back to
+ * the current time, so its bytes — and its tag — change on every poll. Feeds
+ * under test therefore all carry content.
+ */
+async function seed(services: ReturnType<typeof createTestApp>["services"]) {
+  await services.posts.create({
+    format: "note",
+    title: "Featured note",
+    bodyMarkdown: "Featured body",
+    status: "published",
+    featured: true,
+  });
+  await services.posts.create({
+    format: "quote",
+    title: "A quote",
+    quoteText: "Something worth keeping",
+    bodyMarkdown: "Quote body",
+    status: "published",
+  });
+
+  for (const [slug, title] of [
+    ["reading", "Reading"],
+    ["movies", "Movies"],
+  ] as const) {
+    const collection = await services.collections.create({ slug, title });
+    const post = await services.posts.create({
+      format: "note",
+      title: `${title} log`,
+      bodyMarkdown: `${title} body`,
+      status: "published",
+    });
+    await services.collections.addThread(collection.id, post.id);
+  }
+
+  await services.smartCollections.create({
+    slug: "quotes",
+    title: "Quotes",
+    selection: { format: "quote" },
+  });
+}
+
+const FEED_PATHS = [
+  ["site main feed", "/feed"],
+  ["latest", "/latest/feed"],
+  ["featured", "/featured/feed"],
+  ["archive", "/archive/feed"],
+  ["single collection", "/reading/feed"],
+  ["collection selection", "/collections/reading+movies/feed"],
+  ["smart collection", "/quotes/feed"],
+] as const;
+
+describe("feed conditional GET", () => {
+  let app: ReturnType<typeof createTestApp>["app"];
+  let services: ReturnType<typeof createTestApp>["services"];
+
+  beforeEach(async () => {
+    const testApp = setup();
+    app = testApp.app;
+    services = testApp.services;
+    await seed(services);
+  });
+
+  describe.each(FEED_PATHS)("%s (%s)", (_name, path) => {
+    it("serves the feed with a strong validator", async () => {
+      const res = await app.request(path);
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get("ETag")).toMatch(ETAG);
+      expect(res.headers.get("Cache-Control")).toBe("public, max-age=60");
+      expect(res.headers.get("Content-Type")).toBe(
+        "application/atom+xml; charset=utf-8",
+      );
+      expect(await res.text()).toContain("<feed");
+    });
+
+    it("re-derives the same tag for an unchanged feed", async () => {
+      const first = await app.request(path);
+      const second = await app.request(path);
+
+      expect(second.headers.get("ETag")).toBe(first.headers.get("ETag"));
+    });
+  });
+
+  it("issues a new tag once the feed changes", async () => {
+    const before = await app.request("/latest/feed");
+    const staleTag = before.headers.get("ETag") as string;
+
+    await services.posts.create({
+      format: "note",
+      title: "Published after the poll",
+      bodyMarkdown: "New body",
+      status: "published",
+    });
+
+    const after = await app.request("/latest/feed");
+
+    expect(after.headers.get("ETag")).not.toBe(staleTag);
+    expect(await after.text()).toContain("Published after the poll");
+  });
+
+  it("gives two different feeds two different tags", async () => {
+    const latest = await app.request("/latest/feed");
+    const featured = await app.request("/featured/feed");
+
+    expect(featured.headers.get("ETag")).not.toBe(latest.headers.get("ETag"));
+  });
+});

package/src/routes/api/__tests__/collections.test.ts

@@ -45,6 +45,30 @@ describe("Collections API Routes", () => {
       expect(body.directoryItems[0].collectionId).toBe(col.id);
     });
 
+    it("returns smart collections with the same two measures", async () => {
+      const { app, services } = createTestApp();
+      app.route("/api/collections", collectionsApiRoutes);
+
+      await services.smartCollections.create({
+        slug: "quotes",
+        title: "Quotes",
+        selection: { format: "quote" },
+      });
+      const quote = await services.posts.create({
+        format: "quote",
+        quoteText: "Worth keeping",
+      });
+
+      const res = await app.request("/api/collections");
+      const body = await res.json();
+
+      expect(body.smartCollections).toHaveLength(1);
+      expect(body.smartCollections[0].threadCount).toBe(1);
+      expect(body.smartCollections[0].recentActivityAt).toBe(
+        quote.lastActivityAt,
+      );
+    });
+
     it("returns divider labels", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/api/collections", collectionsApiRoutes);
@@ -143,6 +167,61 @@ describe("Collections API Routes", () => {
     });
   });
 
+  describe("GET /api/collections/slug", () => {
+    it("answers whether an address is free", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      await services.collections.create({ slug: "tech", title: "Tech" });
+
+      const taken = await app.request(
+        "/api/collections/slug?mode=check&slug=tech",
+      );
+      expect(taken.status).toBe(200);
+      expect(await taken.json()).toEqual({ slug: "tech", available: false });
+
+      const free = await app.request(
+        "/api/collections/slug?mode=check&slug=reading",
+      );
+      expect(await free.json()).toEqual({ slug: "reading", available: true });
+    });
+
+    it("ignores the address the named collection already holds", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const collection = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+
+      const res = await app.request(
+        `/api/collections/slug?mode=check&slug=tech&collectionId=${collection.id}`,
+      );
+      expect(await res.json()).toEqual({ slug: "tech", available: true });
+    });
+
+    it("refuses a reserved address rather than calling it taken", async () => {
+      const { app } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request(
+        "/api/collections/slug?mode=check&slug=settings",
+      );
+      expect(res.status).toBe(400);
+    });
+
+    it("returns 401 when not authenticated", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const res = await app.request(
+        "/api/collections/slug?mode=check&slug=tech",
+      );
+      expect(res.status).toBe(401);
+    });
+  });
+
   describe("POST /api/collections", () => {
     it("returns 401 when not authenticated", async () => {
       const { app } = createTestApp({ authenticated: false });
@@ -458,6 +537,41 @@ describe("Collections API Routes", () => {
       expect(reordered[1]?.id).toBe(itemC?.id);
       expect(reordered[2]?.id).toBe(itemB?.id);
     });
+
+    it("moves a smart collection, which the directory names by its own id", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const a = await services.collections.create({ slug: "a", title: "A" });
+      const b = await services.collections.create({ slug: "b", title: "B" });
+      const quotes = await services.smartCollections.create({
+        slug: "quotes",
+        title: "Quotes",
+      });
+
+      const items = await services.collections.listDirectoryItems();
+
+      // The shape the drag surface sends: a smart collection id beside a
+      // directory row id.
+      const res = await app.request(
+        `/api/collections/directory-items/${quotes.id}/move`,
+        {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            after: items[0]?.id ?? "",
+            before: items[1]?.id ?? "",
+          }),
+        },
+      );
+
+      expect(res.status).toBe(200);
+
+      const reordered = await services.collections.listDirectoryItems();
+      expect(
+        reordered.map((item) => item.collectionId ?? item.smartCollectionId),
+      ).toEqual([a.id, quotes.id, b.id]);
+    });
   });
 
   describe("POST /api/collections/:id/threads", () => {