@jant/core 0.6.16 → 0.7.1

package/src/routes/pages/__tests__/post-page-round-trips.test.ts

@@ -0,0 +1,211 @@
+/**
+ * Round-trip budget for the post page.
+ *
+ * On Workers a public page's cost is almost entirely the number of sequential
+ * D1 reads it makes — the same render against local SQLite is about a
+ * millisecond. Serving `/{slug}` used to read `path_registry` twice for one
+ * address and the `post` table four times for one post, and nothing failed
+ * when it did. These tests are that missing failure.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { withConfig } from "../../../middleware/config.js";
+import { i18nMiddleware } from "../../../i18n/index.js";
+import { normalizePath, toPublicHref } from "../../../lib/url.js";
+import { pageRoutes } from "../page.js";
+
+/**
+ * Mount the catch-all behind the middleware `createApp()` puts in front of it.
+ *
+ * The stored-redirect middleware is reproduced rather than imported because it
+ * is defined inline in `app.tsx`; what is under test is that it hands its
+ * lookup on and the route takes it, so the stash is the part that must match.
+ */
+function createPostPageApp() {
+  const testApp = createTestApp();
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+
+  app.use("*", async (c, next) => {
+    const storedPath = normalizePath(new URL(c.req.url).pathname);
+    const record = await c.var.services.paths.resolve(storedPath);
+    c.set("pathLookup", { path: storedPath, record });
+    if (record?.kind === "redirect" && record.redirectToPath) {
+      return c.redirect(
+        toPublicHref(`/${record.redirectToPath}`),
+        record.redirectType ?? 301,
+      );
+    }
+    await next();
+  });
+  app.use("*", withConfig());
+  app.use("*", i18nMiddleware());
+  app.route("/", pageRoutes);
+
+  return testApp;
+}
+
+/** Every SQL statement prepared while `run` executes. */
+async function captureStatements<T>(
+  sqlite: ReturnType<typeof createTestApp>["sqlite"],
+  run: () => Promise<T>,
+): Promise<[T, string[]]> {
+  const original = sqlite.prepare.bind(sqlite);
+  const statements: string[] = [];
+  const spy = vi.spyOn(sqlite, "prepare").mockImplementation(((
+    source: string,
+  ) => {
+    statements.push(source.replace(/\s+/g, " "));
+    return original(source);
+  }) as typeof sqlite.prepare);
+  try {
+    return [await run(), statements];
+  } finally {
+    spy.mockRestore();
+  }
+}
+
+/** Reads that resolve one address, i.e. filter `path_registry` by `path`. */
+function countAddressLookups(statements: string[]): number {
+  return statements.filter(
+    (sql) =>
+      /from "path_registry"/i.test(sql) &&
+      /"path_registry"\."path" = \?/i.test(sql),
+  ).length;
+}
+
+/** Reads that scan the `post` table. */
+function countPostReads(statements: string[]): number {
+  return statements.filter((sql) => /from "post"/i.test(sql)).length;
+}
+
+describe("post page round trips", () => {
+  it("resolves the requested address once, and keeps its post reads to three", async () => {
+    const { app, services, sqlite } = createPostPageApp();
+    const post = await services.posts.create({
+      format: "note",
+      title: "Budget",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+
+    const [res, statements] = await captureStatements(sqlite, () =>
+      app.request(`/${post.slug}`),
+    );
+    expect(res.status).toBe(200);
+
+    // The middleware's lookup is the route's lookup.
+    expect(countAddressLookups(statements)).toBe(1);
+
+    // Three reads, and each is for something different: the post with its
+    // canonical alias, its thread, and the thread ids that collection
+    // membership is keyed by. A root post's visibility rides along in its own
+    // row, so nothing goes back for that.
+    expect(countPostReads(statements)).toBe(3);
+  });
+
+  it("redirects a slug to its custom URL without a separate alias lookup", async () => {
+    const { app, services, sqlite } = createPostPageApp();
+    const post = await services.posts.create({
+      format: "note",
+      title: "Renamed",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+    await services.customUrls.create({
+      path: "renamed-url",
+      targetType: "post",
+      targetId: post.id,
+    });
+
+    const [res, statements] = await captureStatements(sqlite, () =>
+      app.request(`/${post.slug}`),
+    );
+    expect(res.status).toBe(301);
+    expect(res.headers.get("location")).toBe("/renamed-url");
+
+    // The address lookup, and nothing more: the alias came back with the post.
+    expect(countAddressLookups(statements)).toBe(1);
+    expect(countPostReads(statements)).toBe(1);
+  });
+
+  it("takes the newest alias as the canonical address", async () => {
+    const { app, services } = createPostPageApp();
+    const post = await services.posts.create({
+      format: "note",
+      title: "Renamed twice",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+    await services.customUrls.create({
+      path: "first-name",
+      targetType: "post",
+      targetId: post.id,
+    });
+    await services.customUrls.create({
+      path: "second-name",
+      targetType: "post",
+      targetId: post.id,
+    });
+
+    const res = await app.request(`/${post.slug}`);
+    expect(res.status).toBe(301);
+    expect(res.headers.get("location")).toBe("/second-name");
+  });
+});
+
+describe("post list round trips", () => {
+  it("reads thread-root visibility from the rows it already loaded", async () => {
+    const { services, sqlite } = createTestApp();
+    for (let i = 0; i < 3; i++) {
+      await services.posts.create({
+        format: "note",
+        title: `Post ${i}`,
+        bodyMarkdown: "Body",
+        status: "published",
+      });
+    }
+
+    const [listed, statements] = await captureStatements(sqlite, () =>
+      services.posts.list({ status: "published", excludeReplies: true }),
+    );
+
+    expect(listed).toHaveLength(3);
+    // A list of thread roots carries its own visibility, so the only `post`
+    // read is the list itself.
+    expect(countPostReads(statements)).toBe(1);
+  });
+
+  it("still looks up the root for a reply loaded on its own", async () => {
+    const { services, sqlite } = createTestApp();
+    const root = await services.posts.create({
+      format: "note",
+      title: "Root",
+      bodyMarkdown: "Body",
+      status: "published",
+      visibility: "private",
+    });
+    const reply = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Reply",
+      replyToId: root.id,
+      status: "published",
+    });
+
+    const [loaded, statements] = await captureStatements(sqlite, () =>
+      services.posts.getById(reply.id),
+    );
+
+    // A reply's own visibility column is null — it inherits the root's — and
+    // the root is not among the rows loaded here, so the second read is what
+    // makes the reply private too.
+    expect(countPostReads(statements)).toBe(2);
+    expect(loaded?.visibility).toBe("private");
+  });
+});

package/src/routes/pages/__tests__/post-preview-partial.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { partialPageRoutes } from "../partials.js";
+
+function createPartialTestApp(options: { authenticated?: boolean } = {}) {
+  const testApp = createTestApp(options);
+  testApp.app.route("/", partialPageRoutes);
+  return testApp;
+}
+
+describe("/_/post-preview/:postId", () => {
+  it("renders the post the way its own page does", async () => {
+    // The composer shows this while writing a translation, and the original's
+    // structure is part of what gets translated — so it has to arrive as the
+    // post, not as a body-only excerpt.
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      title: "Yirgacheffe",
+      bodyMarkdown: "## Brewing\n\nNinety-two degrees was too hot.",
+      status: "published",
+    });
+
+    const res = await app.request(`/_/post-preview/${post.id}`);
+
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("Yirgacheffe");
+    expect(html).toContain("Brewing");
+    expect(html).toContain("Ninety-two degrees was too hot.");
+    // Detail styling, not the feed card's summary.
+    expect(html).toContain("post-detail-title");
+  });
+
+  it("carries a quote's attribution, which a body-only preview would drop", async () => {
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    // A Quote stores its attribution in `title` / `url`; the API surfaces the
+    // same two as `sourceName` / `sourceUrl`.
+    const post = await services.posts.create({
+      format: "quote",
+      quoteText: "Focus is about saying no.",
+      title: "Some Author",
+      url: "https://example.com/focus",
+      status: "published",
+    });
+
+    const html = await (await app.request(`/_/post-preview/${post.id}`)).text();
+
+    expect(html).toContain("Focus is about saying no.");
+    expect(html).toContain("Some Author");
+    expect(html).toContain("https://example.com/focus");
+  });
+
+  it("offers no control that would act on the post being previewed", async () => {
+    // Every action in the composer belongs to the post being written. A menu
+    // or reply trigger here would aim at the wrong one.
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      title: "Yirgacheffe",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+
+    const html = await (await app.request(`/_/post-preview/${post.id}`)).text();
+
+    expect(html).not.toContain("data-post-menu-trigger");
+    expect(html).not.toContain("data-reply-trigger");
+  });
+
+  it("prints a titled post's date once, not in both header and footer", async () => {
+    // The card drops the footer's copy for a titled detail post, but only when
+    // `hideTimestamp` is left undefined — stating it either way brings it back.
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      title: "Yirgacheffe",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+
+    const html = await (await app.request(`/_/post-preview/${post.id}`)).text();
+
+    expect(html.match(/<time/g) ?? []).toHaveLength(1);
+  });
+
+  it("404s on a post that is not there", async () => {
+    const { app } = createPartialTestApp({ authenticated: true });
+
+    const res = await app.request(
+      "/_/post-preview/pst_01000000000000000000000000",
+    );
+
+    expect(res.status).toBe(404);
+  });
+});

package/src/routes/pages/__tests__/smart-collection.test.ts

@@ -0,0 +1,298 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { pageRoutes } from "../page.js";
+
+/**
+ * The smart collection page, end to end through the path registry.
+ *
+ * The property these guard is the one the design turns on: a smart collection
+ * is always public, and the posts inside it are exactly as visible as they are
+ * anywhere else. Those are different sentences, and confusing them is how a
+ * page ends up either 404ing for readers or leaking a draft.
+ */
+
+function setup(authenticated = false) {
+  const { app, services } = createTestApp({ authenticated });
+  app.route("/", pageRoutes);
+  return { app, services };
+}
+
+async function seedQuotes(services: {
+  posts: {
+    create: (input: Record<string, unknown>) => Promise<{ id: string }>;
+  };
+}) {
+  await services.posts.create({
+    format: "quote",
+    quoteText: "A public quote",
+    bodyMarkdown: "public quote body",
+    status: "published",
+  });
+  await services.posts.create({
+    format: "quote",
+    quoteText: "A private quote",
+    bodyMarkdown: "private quote body",
+    status: "published",
+    visibility: "private",
+  });
+  await services.posts.create({
+    format: "note",
+    bodyMarkdown: "a plain note body",
+    status: "published",
+  });
+}
+
+describe("smart collection page", () => {
+  it("renders for a signed-out reader, with title, count, and description", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      description: "Things worth keeping.",
+      selection: { format: "quote" },
+    });
+
+    const res = await app.request("/quotes");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html).toContain("Quotes");
+    expect(html).toContain("Things worth keeping.");
+    // A written description takes the slot; the conditions — and the way to
+    // the archive — stay reachable through the marker beside the title.
+    expect(html).not.toContain(">Automatically collects: Quotes<");
+    expect(html).toContain('title="Automatically collects: Quotes"');
+    expect(html).toContain(
+      '<a href="/archive?format=quote" class="collection-page-smart-icon"',
+    );
+    expect(html).toContain("public quote body");
+    expect(html).not.toContain("a plain note body");
+    // The archive has a chip bar; this page does not.
+    expect(html).not.toContain("archive-filters-chips");
+  });
+
+  it("describes itself by its conditions until a description is written", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+
+    const html = await (await app.request("/quotes")).text();
+    expect(html).toContain(">Automatically collects: Quotes<");
+  });
+
+  it("links its conditions to the archive showing the same posts", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote", media: "none" },
+    });
+
+    const html = await (await app.request("/quotes")).text();
+    expect(html).toContain("/archive?format=quote&amp;media=none");
+  });
+
+  it("says so when nothing matches, rather than rendering blank", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "links",
+      title: "Links",
+      selection: { format: "link" },
+    });
+
+    const html = await (await app.request("/links")).text();
+    expect(html).toContain("Nothing matches these conditions yet.");
+  });
+
+  it("collects every post when no condition narrows it", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "everything",
+      title: "Everything",
+    });
+
+    const html = await (await app.request("/everything")).text();
+    expect(html).toContain("Automatically collects every post.");
+    expect(html).toContain("public quote body");
+    expect(html).toContain("a plain note body");
+  });
+
+  // The whole point of forbidding private conditions: there is no smart
+  // collection page that answers 404 to a reader.
+  it("shows the private post to its author and to nobody else", async () => {
+    const reader = setup(false);
+    await seedQuotes(reader.services);
+    await reader.services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+    const readerHtml = await (await reader.app.request("/quotes")).text();
+    expect(readerHtml).toContain("public quote body");
+    expect(readerHtml).not.toContain("private quote body");
+    expect(readerHtml).toContain("1 thread");
+
+    const authorApp = setup(true);
+    await seedQuotes(authorApp.services);
+    await authorApp.services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+    const authorHtml = await (await authorApp.app.request("/quotes")).text();
+    expect(authorHtml).toContain("private quote body");
+    expect(authorHtml).toContain("2 threads");
+  });
+
+  it("ignores condition parameters in the URL", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+
+    // Membership is edited in the dialog. A reader appending `?format=note`
+    // must not be able to redefine what the page collects.
+    const html = await (await app.request("/quotes?format=note")).text();
+    expect(html).toContain("public quote body");
+    expect(html).not.toContain("a plain note body");
+  });
+
+  it("honors ?sort= over the stored default", async () => {
+    const { app, services } = setup();
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Older",
+      bodyMarkdown: "older body",
+      status: "published",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Newer",
+      bodyMarkdown: "newer body",
+      status: "published",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+      sort: "newest",
+    });
+
+    const stored = await (await app.request("/quotes")).text();
+    expect(stored.indexOf("newer body")).toBeLessThan(
+      stored.indexOf("older body"),
+    );
+
+    const flipped = await (await app.request("/quotes?sort=oldest")).text();
+    expect(flipped.indexOf("older body")).toBeLessThan(
+      flipped.indexOf("newer body"),
+    );
+  });
+
+  it("orders newest by date, not by rating", async () => {
+    const { app, services } = setup();
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Older",
+      bodyMarkdown: "older body",
+      status: "published",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+      rating: 5,
+    });
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Newer",
+      bodyMarkdown: "newer body",
+      status: "published",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+      rating: 1,
+    });
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+      sort: "newest",
+    });
+
+    // The page once handed `newest` to a query that read it as the ascending
+    // rating order, which put the worst-rated post on top of a dated page.
+    const page = await (await app.request("/quotes")).text();
+    expect(page.indexOf("newer body")).toBeLessThan(page.indexOf("older body"));
+  });
+
+  it("still answers a link to the retired ?sort=updated", async () => {
+    const { app, services } = setup();
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Older",
+      bodyMarkdown: "older body",
+      status: "published",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Newer",
+      bodyMarkdown: "newer body",
+      status: "published",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+      // A stored order the legacy value must not fall back to, or the test
+      // would pass on the fallback rather than on the mapping.
+      sort: "oldest",
+    });
+
+    const legacy = await (await app.request("/quotes?sort=updated")).text();
+    expect(legacy.indexOf("newer body")).toBeLessThan(
+      legacy.indexOf("older body"),
+    );
+  });
+
+  it("404s an address no smart collection holds", async () => {
+    const { app } = setup();
+    expect((await app.request("/nothing-here")).status).toBe(404);
+  });
+});
+
+describe("smart collection feed", () => {
+  it("serves an anonymous feed with no guard to trip over", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+
+    const res = await app.request("/quotes/feed");
+    expect(res.status).toBe(200);
+    const xml = await res.text();
+
+    expect(xml).toContain("A public quote");
+    // A feed carries no session, so the private quote can never appear in one.
+    expect(xml).not.toContain("A private quote");
+    expect(xml).toContain('rel="self"');
+    expect(xml).toContain("/quotes/feed");
+  });
+
+  it("404s a feed for an address no smart collection holds", async () => {
+    const { app } = setup();
+    expect((await app.request("/nothing-here/feed")).status).toBe(404);
+  });
+});