@jant/core 0.6.16 → 0.7.0

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", () => {

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

@@ -0,0 +1,222 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { enforceD1BoundParameterLimit } from "../../../__tests__/helpers/db.js";
+import { DISCOVER_STATUS_MAX_IDS } from "../../../lib/discover.js";
+import { createEntityId } from "../../../lib/ids.js";
+import { discoverApiRoutes } from "../discover.js";
+
+type Status = { id: string; latest: boolean; featured: boolean };
+
+async function setupApp(
+  options: Parameters<typeof createTestApp>[0] = {},
+  { discover = "latest" }: { discover?: string | null } = {},
+) {
+  const testApp = createTestApp({ authenticated: false, ...options });
+  testApp.app.route("/api/discover", discoverApiRoutes);
+  if (discover) await testApp.services.settings.set("DISCOVER", discover);
+  return testApp;
+}
+
+async function ask(
+  app: { request: (path: string) => Promise<Response> },
+  ids: string[],
+  extra = "",
+): Promise<Status[]> {
+  const query = ids.map((id) => `id=${id}`).join("&");
+  const res = await app.request(`/api/discover/posts?${query}${extra}`);
+  expect(res.status).toBe(200);
+  const body = (await res.json()) as { posts: Status[] };
+  return body.posts;
+}
+
+describe("GET /api/discover/posts", () => {
+  it("says whether each post is in the Latest and featured feeds", async () => {
+    const { app, services } = await setupApp();
+    const plain = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "plain",
+    });
+    const featured = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "featured",
+      featured: true,
+    });
+    const hiddenFeatured = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "hidden from Latest, still featured",
+      visibility: "latest_hidden",
+      featured: true,
+    });
+
+    expect(await ask(app, [plain.id, featured.id, hiddenFeatured.id])).toEqual([
+      { id: plain.id, latest: true, featured: false },
+      { id: featured.id, latest: true, featured: true },
+      { id: hiddenFeatured.id, latest: false, featured: true },
+    ]);
+  });
+
+  it("answers false for every way a post can be gone", async () => {
+    const { app, services } = await setupApp();
+    const privatePost = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "private",
+      visibility: "private",
+      featured: true,
+    });
+    const draft = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "draft",
+      status: "draft",
+    });
+    const deleted = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "deleted",
+      featured: true,
+    });
+    await services.posts.delete(deleted.id);
+    const unknown = createEntityId("post");
+
+    const ids = [privatePost.id, draft.id, deleted.id, unknown];
+    expect(await ask(app, ids)).toEqual(
+      ids.map((id) => ({ id, latest: false, featured: false })),
+    );
+  });
+
+  it("counts a Thread featured when a reply in it is", async () => {
+    const { app, services } = await setupApp();
+    const root = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "root",
+    });
+    const reply = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "featured reply",
+      replyToId: root.id,
+      featured: true,
+    });
+
+    // A reply is never an entry of its own, so it is in neither feed; its
+    // Thread is in both.
+    expect(await ask(app, [root.id, reply.id])).toEqual([
+      { id: root.id, latest: true, featured: true },
+      { id: reply.id, latest: false, featured: false },
+    ]);
+  });
+
+  it("holds a new post back for the RSS delay, as the feeds do", async () => {
+    const { app, services } = await setupApp({ rssPublishDelaySeconds: 300 });
+    const currentTime = Math.floor(Date.now() / 1000);
+    const settled = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "settled",
+      publishedAt: currentTime - 400,
+    });
+    const fresh = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "fresh",
+      publishedAt: currentTime,
+    });
+
+    expect(await ask(app, [settled.id, fresh.id])).toEqual([
+      { id: settled.id, latest: true, featured: false },
+      { id: fresh.id, latest: false, featured: false },
+    ]);
+  });
+
+  it("scopes the answer to one language view with ?lang=", async () => {
+    const { app, services } = await setupApp();
+    await services.settings.set("SITE_LANGUAGE", "zh-Hans");
+    await services.settings.set("ADDITIONAL_LANGUAGES", "en");
+    await services.settings.set("MULTILINGUAL_ENABLED", "true");
+    const english = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "hello",
+      language: "en",
+    });
+
+    expect(await ask(app, [english.id], "&lang=en")).toEqual([
+      { id: english.id, latest: true, featured: false },
+    ]);
+    expect(await ask(app, [english.id], "&lang=zh-Hans")).toEqual([
+      { id: english.id, latest: false, featured: false },
+    ]);
+  });
+
+  it("answers each post once, in the order asked", async () => {
+    const { app, services } = await setupApp();
+    const first = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "first",
+    });
+    const second = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "second",
+    });
+
+    const answer = await ask(app, [second.id, first.id, second.id]);
+
+    expect(answer.map((status) => status.id)).toEqual([second.id, first.id]);
+  });
+
+  it("fits a full request within D1's bound-parameter limit", async () => {
+    const { app, services, sqlite } = await setupApp();
+    const real = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "real",
+      featured: true,
+    });
+    const ids = [
+      real.id,
+      ...Array.from({ length: DISCOVER_STATUS_MAX_IDS - 1 }, () =>
+        createEntityId("post"),
+      ),
+    ];
+    enforceD1BoundParameterLimit(sqlite);
+
+    const answer = await ask(app, ids);
+
+    expect(answer).toHaveLength(DISCOVER_STATUS_MAX_IDS);
+    expect(answer[0]).toEqual({ id: real.id, latest: true, featured: true });
+  });
+
+  it("rejects a request with no ids, too many, or one that is not a post ID", async () => {
+    const { app } = await setupApp();
+    const tooMany = Array.from(
+      { length: DISCOVER_STATUS_MAX_IDS + 1 },
+      () => `id=${createEntityId("post")}`,
+    ).join("&");
+
+    for (const query of [
+      "",
+      tooMany,
+      "id=not-an-id",
+      `id=${createEntityId("collection")}`,
+    ]) {
+      const res = await app.request(`/api/discover/posts?${query}`);
+      expect(res.status, query.slice(0, 40)).toBe(400);
+    }
+  });
+
+  it("is not there for a site that is not in Discover", async () => {
+    const { app } = await setupApp({}, { discover: "off" });
+
+    const res = await app.request(
+      `/api/discover/posts?id=${createEntityId("post")}`,
+    );
+
+    expect(res.status).toBe(404);
+  });
+
+  it("still answers when the public JSON API is turned off", async () => {
+    const { app, services } = await setupApp();
+    await services.settings.set("PUBLIC_API_ENABLED", "false");
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "listed",
+    });
+
+    expect(await ask(app, [post.id])).toEqual([
+      { id: post.id, latest: true, featured: false },
+    ]);
+  });
+});