@jant/core 0.6.16 → 0.7.1

package/src/routes/api/smart-collections.ts

@@ -0,0 +1,132 @@
+/**
+ * Smart Collections API Routes
+ */
+
+import { Hono } from "hono";
+import { z } from "zod";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../types/app-context.js";
+import { requireAuthApi } from "../../middleware/auth.js";
+import {
+  ContentLanguageSchema,
+  CreateSmartCollectionSchema,
+  SmartCollectionIdSchema,
+  SmartCollectionPreviewSchema,
+  UpdateSmartCollectionSchema,
+  parseValidated,
+} from "../../lib/schemas.js";
+import { assertFound, parseIdParam } from "../../lib/errors.js";
+import { ID_PREFIX } from "../../lib/ids.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const smartCollectionsApiRoutes = new Hono<Env>();
+
+/**
+ * Address availability, in the shape posts already use.
+ *
+ * `suggest` derives one from a title; `check` answers whether a typed one is
+ * free. Collections answer the same question at `/api/collections/slug`.
+ */
+const SlugQuerySchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("suggest"),
+    title: z.string().trim().max(300).optional(),
+    smartCollectionId: SmartCollectionIdSchema.optional(),
+  }),
+  z.object({
+    mode: z.literal("check"),
+    slug: z.string().trim().toLowerCase().min(1).max(200),
+    smartCollectionId: SmartCollectionIdSchema.optional(),
+  }),
+]);
+
+const PreviewQuerySchema = z.object({
+  lang: ContentLanguageSchema.optional(),
+});
+
+// --- Address ---------------------------------------------------------------
+// Declared before `/:id` so the literal path wins.
+
+smartCollectionsApiRoutes.get("/slug", requireAuthApi(), async (c) => {
+  const query = parseValidated(SlugQuerySchema, c.req.query());
+
+  if (query.mode === "suggest") {
+    const slug = await c.var.services.smartCollections.suggestSlug({
+      title: query.title,
+      excludeId: query.smartCollectionId,
+    });
+    return c.json({ slug });
+  }
+
+  const available = await c.var.services.smartCollections.checkSlugAvailability(
+    query.slug,
+    query.smartCollectionId,
+  );
+  return c.json({ slug: query.slug, available });
+});
+
+// --- Preview ---------------------------------------------------------------
+
+/**
+ * How many threads a set of conditions would gather, against the site total.
+ *
+ * POST rather than GET: the conditions are a typed body in the same shape the
+ * create endpoint validates, and putting them in a URL would mean inventing a
+ * second spelling for them.
+ */
+smartCollectionsApiRoutes.post("/preview", requireAuthApi(), async (c) => {
+  const body = parseValidated(SmartCollectionPreviewSchema, await c.req.json());
+  const query = parseValidated(PreviewQuerySchema, c.req.query());
+
+  const { count, baseline } = await c.var.services.smartCollections.preview(
+    body.selection ?? {},
+    { isAuthenticated: c.var.isAuthenticated, lang: query.lang },
+  );
+
+  c.header("Cache-Control", "no-store");
+  return c.json({ count, baseline });
+});
+
+// --- CRUD ------------------------------------------------------------------
+
+smartCollectionsApiRoutes.get("/", requireAuthApi(), async (c) => {
+  const query = parseValidated(PreviewQuerySchema, c.req.query());
+  const smartCollections =
+    await c.var.services.smartCollections.listDirectoryEntries({
+      isAuthenticated: c.var.isAuthenticated,
+      lang: query.lang,
+    });
+  return c.json({ smartCollections });
+});
+
+smartCollectionsApiRoutes.post("/", requireAuthApi(), async (c) => {
+  const body = parseValidated(CreateSmartCollectionSchema, await c.req.json());
+  const smartCollection = await c.var.services.smartCollections.create(body);
+  return c.json({ smartCollection }, 201);
+});
+
+smartCollectionsApiRoutes.get("/:id", requireAuthApi(), async (c) => {
+  const id = parseIdParam(c.req.param("id"), ID_PREFIX.smartCollection);
+  const smartCollection = await c.var.services.smartCollections.getById(id);
+  assertFound(smartCollection, "Smart collection");
+  return c.json({ smartCollection });
+});
+
+smartCollectionsApiRoutes.put("/:id", requireAuthApi(), async (c) => {
+  const id = parseIdParam(c.req.param("id"), ID_PREFIX.smartCollection);
+  const body = parseValidated(UpdateSmartCollectionSchema, await c.req.json());
+  const smartCollection = await c.var.services.smartCollections.update(
+    id,
+    body,
+  );
+  assertFound(smartCollection, "Smart collection");
+  return c.json({ smartCollection });
+});
+
+smartCollectionsApiRoutes.delete("/:id", requireAuthApi(), async (c) => {
+  const id = parseIdParam(c.req.param("id"), ID_PREFIX.smartCollection);
+  const deleted = await c.var.services.smartCollections.delete(id);
+  assertFound(deleted || null, "Smart collection");
+  return c.json({ success: true });
+});

package/src/routes/api/telegram.ts

@@ -25,6 +25,7 @@ import {
   getTelegramWebhookSecret,
 } from "../../lib/env.js";
 import { timingSafeEqualText } from "../../lib/crypto.js";
+import { runDeferred } from "../../lib/deferred.js";
 import {
   answerCallbackQuery,
   buildDeepLink,
@@ -316,7 +317,7 @@ async function processUpdate(
       posterFileId: media.posterFileId ?? null,
     });
 
-    runDeferred(c, async () => {
+    runDeferred(c, "Telegram", async () => {
       await sleep(ALBUM_BUFFER_DELAY_MS);
       const claimed = await telegram.claimAlbumGroup(botId, mediaGroupId);
       if (claimed.length === 0) return;
@@ -371,45 +372,6 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-/**
- * Schedules background work that must outlive the current HTTP response so
- * Telegram can deliver the next webhook in this chat without waiting.
- *
- * On Cloudflare Workers `c.executionCtx.waitUntil` keeps the worker alive
- * until the promise settles. In Node / tests there's no such API, so we just
- * let the promise float — Node's event loop keeps running it. Either way the
- * promise has its own try/catch so unhandled rejections never bubble up.
- *
- * Background work also tracks the pending-promises array we register on the
- * env binding for tests so a vitest can `await` them after advancing timers.
- */
-function runDeferred(
-  c: {
-    env: Bindings;
-    executionCtx?: { waitUntil: (promise: Promise<unknown>) => void };
-  },
-  work: () => Promise<void>,
-): void {
-  const promise = work().catch((err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    // eslint-disable-next-line no-console -- Background failures must be visible.
-    console.error(`[Jant] Telegram background error: ${message}`);
-  });
-  try {
-    c.executionCtx?.waitUntil(promise);
-  } catch {
-    // executionCtx not available (e.g. Node, tests) — promise still runs.
-  }
-  const pending = (
-    c.env as Bindings & {
-      __telegramPending?: Promise<unknown>[];
-    }
-  ).__telegramPending;
-  if (Array.isArray(pending)) {
-    pending.push(promise);
-  }
-}
-
 /**
  * Convert a message's caption + caption_entities into markdown, returning
  * `null` when there's nothing to record. Centralized so single-media and album

package/src/routes/api/upload.ts

@@ -39,7 +39,7 @@ import {
 } from "../../lib/errors.js";
 import { getI18n } from "../../i18n/index.js";
 import { ID_PREFIX } from "../../lib/ids.js";
-import { parseValidated } from "../../lib/schemas.js";
+import { MediaIdSchema, parseValidated } from "../../lib/schemas.js";
 import { toApiMedia } from "../../lib/api-media.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
@@ -49,6 +49,7 @@ export const uploadApiRoutes = new Hono<Env>();
 const ListMediaQuerySchema = z.object({
   limit: z.coerce.number().int().min(1).max(200).optional().default(50),
   mimePrefix: z.string().trim().min(1).optional(),
+  cursor: MediaIdSchema.optional(),
 });
 
 const UpdateMediaSchema = z.object({
@@ -421,14 +422,20 @@ uploadApiRoutes.post("/", async (c) => {
 
 // List uploaded files (JSON only)
 uploadApiRoutes.get("/", async (c) => {
-  const { limit, mimePrefix } = parseValidated(
+  const { limit, mimePrefix, cursor } = parseValidated(
     ListMediaQuerySchema,
     c.req.query(),
   );
-  const mediaList = await c.var.services.media.list({ limit, mimePrefix });
+  const mediaList = await c.var.services.media.list({
+    limit,
+    mimePrefix,
+    cursor,
+  });
 
   return c.json({
     media: mediaList.map((media) => toApiMedia(media, c.var.appConfig)),
+    nextCursor:
+      mediaList.length === limit ? (mediaList.at(-1)?.id ?? null) : null,
   });
 });
 

package/src/routes/api/uploads.ts

@@ -116,8 +116,7 @@ function scheduleExpiredUploadCleanup(
     .catch(() => {});
 
   let executionCtx:
-    | { waitUntil: (promise: Promise<unknown>) => void }
-    | undefined;
+    { waitUntil: (promise: Promise<unknown>) => void } | undefined;
   try {
     executionCtx = c.executionCtx;
   } catch {

package/src/routes/auth/__tests__/setup-auth.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for who may answer the last setup question on a provisioned site.
+ *
+ * A provisioned site already has an owner, so `POST /setup` writes the site's
+ * name and language on behalf of that owner. Carrying a session is not enough
+ * to be that owner — the session may belong to someone this site has never
+ * heard of.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { Hono } from "hono";
+import { createI18n } from "../../../i18n/index.js";
+import { attachSession } from "../../../middleware/session.js";
+import { ONBOARDING_STATUS } from "../../../lib/constants.js";
+import { setupRoutes } from "../setup.js";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+function createMockAuth(signedIn: boolean) {
+  return {
+    api: {
+      getSession: async () => ({
+        headers: new Headers(),
+        response: signedIn
+          ? {
+              user: {
+                id: "usr_outsider",
+                email: "someone@test.com",
+                name: "S",
+              },
+              session: { id: "ses_outsider" },
+            }
+          : null,
+      }),
+    },
+  } as unknown as AppVariables["auth"];
+}
+
+function createProvisionedSetupApp(options: {
+  signedIn: boolean;
+  isMember: boolean;
+}) {
+  const completeSiteSetup = vi.fn(async () => {});
+
+  const app = new Hono<Env>();
+  app.use("*", async (c, next) => {
+    c.env = {} as Bindings;
+    c.set("auth", createMockAuth(options.signedIn));
+    c.set("services", {
+      settings: {
+        getOnboardingStatus: async () => ONBOARDING_STATUS.PROVISIONED,
+        get: async () => "My Blog",
+      },
+      bootstrap: { completeSiteSetup },
+      siteMembers: {
+        get: async () =>
+          options.isMember
+            ? {
+                createdAt: 0,
+                role: "owner",
+                siteId: "sit_test",
+                updatedAt: 0,
+                userId: "usr_outsider",
+              }
+            : null,
+      },
+    } as unknown as AppVariables["services"]);
+    c.set("currentSite", {
+      createdAt: 0,
+      id: "sit_test",
+      key: "default",
+      status: "active",
+      updatedAt: 0,
+    });
+    c.set("appConfig", {
+      siteName: "Jant",
+      sitePathPrefix: "",
+      siteLanguage: "en",
+    } as AppVariables["appConfig"]);
+    c.set("lang", "en");
+    c.set("i18n", createI18n("en"));
+    await next();
+  });
+  app.use("*", attachSession());
+  app.route("/", setupRoutes);
+
+  return { app, completeSiteSetup };
+}
+
+function postLanguage(app: Hono<Env>) {
+  return app.request("/setup", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ contentLanguage: "zh-Hans" }),
+  });
+}
+
+describe("POST /setup on a provisioned site", () => {
+  it("refuses a session that is not a member of this site", async () => {
+    const { app, completeSiteSetup } = createProvisionedSetupApp({
+      signedIn: true,
+      isMember: false,
+    });
+
+    const res = await postLanguage(app);
+
+    await expect(res.text()).resolves.toContain("/signin");
+    expect(completeSiteSetup).not.toHaveBeenCalled();
+  });
+
+  it("lets the site's own owner answer", async () => {
+    const { app, completeSiteSetup } = createProvisionedSetupApp({
+      signedIn: true,
+      isMember: true,
+    });
+
+    await postLanguage(app);
+
+    expect(completeSiteSetup).toHaveBeenCalledOnce();
+  });
+});
+
+describe("GET /setup on a provisioned site", () => {
+  it("sends a non-member to the site instead of showing the form", async () => {
+    const { app } = createProvisionedSetupApp({
+      signedIn: true,
+      isMember: false,
+    });
+
+    const res = await app.request("/setup", { redirect: "manual" });
+
+    expect(res.status).toBe(302);
+    expect(res.headers.get("Location")).toBe("/");
+  });
+});

package/src/routes/auth/__tests__/setup-discover.test.ts

@@ -0,0 +1,204 @@
+/**
+ * Tests for the Discover answer the setup screen collects.
+ *
+ * The point under test is that setup records an answer rather than inferring
+ * one — a ticked box and a cleared box both write, and a form that carried no
+ * field at all writes nothing, since that last case is an older client or a
+ * scripted setup and reading it as a refusal would opt sites out that never
+ * said so — and then acts on it, on the same terms as the settings page's own
+ * switch.
+ */
+
+import { describe, expect, it, vi } from "vitest";
+import { Hono } from "hono";
+import { createI18n } from "../../../i18n/index.js";
+import { attachSession } from "../../../middleware/session.js";
+import { ONBOARDING_STATUS } from "../../../lib/constants.js";
+import { setupRoutes } from "../setup.js";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+function createMockAuth() {
+  return {
+    api: {
+      getSession: async () => ({
+        headers: new Headers(),
+        response: {
+          user: { id: "usr_owner", email: "owner@test.com", name: "O" },
+          session: { id: "ses_owner" },
+        },
+      }),
+    },
+  } as unknown as AppVariables["auth"];
+}
+
+/**
+ * A provisioned site whose owner is answering. Both install kinds reach the
+ * Discover write through this one branch — a self-hosted site arrives here from
+ * its second screen, a hosted one from its only screen.
+ */
+function createSetupApp(
+  options: { demoMode?: boolean; shouldAnnounce?: boolean } = {},
+) {
+  const completeSiteSetup = vi.fn(async () => {});
+  const updateDiscoverSetting = vi.fn(async () => ({
+    shouldAnnounce: options.shouldAnnounce ?? true,
+  }));
+  const announceToDiscover = vi.fn(async () => {});
+  // The hook `runDeferred` offers tests: every backgrounded promise lands
+  // here, so the announcement can be awaited instead of raced.
+  const pending: Promise<unknown>[] = [];
+
+  const app = new Hono<Env>();
+  app.use("*", async (c, next) => {
+    c.env = {
+      DISCOVER_PING_URL: "https://directory.test/api/discover/ping",
+      __pendingDeferred: pending,
+    } as unknown as Bindings;
+    c.set("auth", createMockAuth());
+    c.set("services", {
+      settings: {
+        getOnboardingStatus: async () => ONBOARDING_STATUS.PROVISIONED,
+        // Already named, so this is the hosted screen: language and Discover
+        // and nothing else.
+        get: async () => "My Blog",
+        updateDiscoverSetting,
+        announceToDiscover,
+      },
+      bootstrap: { completeSiteSetup },
+      siteMembers: {
+        get: async () => ({
+          createdAt: 0,
+          role: "owner",
+          siteId: "sit_test",
+          updatedAt: 0,
+          userId: "usr_owner",
+        }),
+      },
+    } as unknown as AppVariables["services"]);
+    c.set("currentSite", {
+      createdAt: 0,
+      id: "sit_test",
+      key: "default",
+      status: "active",
+      updatedAt: 0,
+    });
+    c.set("appConfig", {
+      siteName: "Jant",
+      sitePathPrefix: "",
+      siteLanguage: "en",
+      siteUrl: "https://example.com",
+      demoMode: options.demoMode ?? false,
+      noindex: false,
+      rssFeedsEnabled: true,
+    } as AppVariables["appConfig"]);
+    c.set("lang", "en");
+    c.set("i18n", createI18n("en"));
+    await next();
+  });
+  app.use("*", attachSession());
+  app.route("/", setupRoutes);
+
+  return { app, updateDiscoverSetting, announceToDiscover, pending };
+}
+
+function post(app: Hono<Env>, body: Record<string, unknown>) {
+  return app.request("/setup", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ contentLanguage: "zh-Hans", ...body }),
+  });
+}
+
+describe("POST /setup, the Discover answer", () => {
+  it("stores `latest` when the box was ticked", async () => {
+    const { app, updateDiscoverSetting } = createSetupApp();
+
+    await post(app, { discover: true });
+
+    expect(updateDiscoverSetting).toHaveBeenCalledWith("latest", {
+      demoMode: false,
+    });
+  });
+
+  // The half that matters on a deployment which lists by default: a cleared box
+  // has to be written, or `DISCOVER=latest` keeps deciding for someone who just
+  // said no.
+  it("stores `off` when the box was cleared", async () => {
+    const { app, updateDiscoverSetting } = createSetupApp();
+
+    await post(app, { discover: false });
+
+    expect(updateDiscoverSetting).toHaveBeenCalledWith("off", {
+      demoMode: false,
+    });
+  });
+
+  it("writes nothing when the form carried no answer", async () => {
+    const { app, updateDiscoverSetting } = createSetupApp();
+
+    await post(app, {});
+
+    expect(updateDiscoverSetting).not.toHaveBeenCalled();
+  });
+
+  // The answer takes effect now, not when the author next happens to open a
+  // settings page they have no reason to open. A directory decides eligibility
+  // for itself and re-reads the feed on its own schedule, so a site with
+  // nothing published yet loses nothing by saying hello early.
+  it("announces the site when the box was ticked", async () => {
+    const { app, announceToDiscover, pending } = createSetupApp();
+
+    await post(app, { discover: true });
+    await Promise.all(pending);
+
+    expect(announceToDiscover).toHaveBeenCalledWith({
+      endpoint: "https://directory.test/api/discover/ping",
+      feedUrl: "https://example.com/latest/feed",
+    });
+  });
+
+  // Not awaited: a directory takes up to twelve seconds to give up on, and the
+  // last screen of setup is not a place to spend them. The outcome is recorded
+  // for the settings page's status block to read back.
+  it("does not hold the response while the directory answers", async () => {
+    const { app, announceToDiscover, pending } = createSetupApp();
+    let settled = false;
+    announceToDiscover.mockImplementation(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      settled = true;
+    });
+
+    await post(app, { discover: true });
+
+    expect(settled).toBe(false);
+    await Promise.all(pending);
+    expect(settled).toBe(true);
+  });
+
+  // Nothing to tell a directory that was never told anything: going from unset
+  // to `off` leaves the site exactly as unlisted as it already was.
+  it("announces nothing when the setting service reports no change", async () => {
+    const { app, announceToDiscover, pending } = createSetupApp({
+      shouldAnnounce: false,
+    });
+
+    await post(app, { discover: false });
+    await Promise.all(pending);
+
+    expect(announceToDiscover).not.toHaveBeenCalled();
+  });
+
+  it("announces nothing from a demo site", async () => {
+    const { app, announceToDiscover, pending } = createSetupApp({
+      demoMode: true,
+    });
+
+    await post(app, { discover: true });
+    await Promise.all(pending);
+
+    expect(announceToDiscover).not.toHaveBeenCalled();
+  });
+});