@jant/core 0.3.39 → 0.3.40

package/src/runtime/readiness.ts

@@ -0,0 +1,129 @@
+import { createDatabase, createNodeDatabase } from "../db/index.js";
+import { sqliteSchemaBundle } from "../db/schema-bundle.js";
+import { getAuthSecret } from "../lib/env.js";
+import { getHostBasedStartupConfigurationIssues } from "../lib/startup-config.js";
+import { createSiteService } from "../services/site.js";
+import type { Bindings } from "../types/bindings.js";
+
+export interface ReadinessCheckStatus {
+  ok: boolean;
+  error?: string;
+}
+
+export interface InstanceReadinessResult {
+  status: "ok" | "error";
+  checks: {
+    startupConfig: ReadinessCheckStatus;
+    database: ReadinessCheckStatus;
+  };
+}
+
+function getStartupConfigurationReadiness(
+  env: Pick<
+    Bindings,
+    | "AUTH_SECRET"
+    | "HOSTED_CONTROL_PLANE_BASE_URL"
+    | "HOSTED_CONTROL_PLANE_DOMAIN_CHECK_SECRET"
+    | "HOSTED_CONTROL_PLANE_INTERNAL_BASE_URL"
+    | "HOSTED_CONTROL_PLANE_INTERNAL_TOKEN"
+    | "HOSTED_CONTROL_PLANE_SSO_SECRET"
+    | "INTERNAL_ADMIN_TOKEN"
+    | "SITE_RESOLUTION_MODE"
+  >,
+): ReadinessCheckStatus {
+  const errors: string[] = [];
+
+  if (!getAuthSecret(env)) {
+    errors.push("AUTH_SECRET must be set before Jant can accept traffic.");
+  }
+
+  for (const issue of getHostBasedStartupConfigurationIssues(env)) {
+    errors.push(`${issue.variable}: ${issue.message}`);
+  }
+
+  return errors.length > 0
+    ? {
+        ok: false,
+        error: errors.join(" "),
+      }
+    : { ok: true };
+}
+
+async function getDatabaseReadiness(
+  env: Pick<Bindings, "DB" | "NODE_DATABASE" | "NODE_SQLITE">,
+): Promise<ReadinessCheckStatus> {
+  try {
+    if (env.NODE_DATABASE?.db) {
+      const siteService = createSiteService(
+        env.NODE_DATABASE.db,
+        env.NODE_DATABASE.schema,
+      );
+      await siteService.getById("sit_readiness_probe");
+      return { ok: true };
+    }
+
+    if (env.NODE_SQLITE) {
+      const siteService = createSiteService(
+        createNodeDatabase(env.NODE_SQLITE),
+      );
+      await siteService.getById("sit_readiness_probe");
+      return { ok: true };
+    }
+
+    if (env.DB) {
+      // Use a D1 session to mirror the normal Cloudflare runtime path.
+      const session = env.DB.withSession();
+      const siteService = createSiteService(
+        createDatabase(session as unknown as D1Database),
+        sqliteSchemaBundle,
+      );
+      await siteService.getById("sit_readiness_probe");
+      return { ok: true };
+    }
+
+    return {
+      ok: false,
+      error: "No database binding is configured for this runtime.",
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Perform instance-scoped readiness checks that bypass site resolution.
+ *
+ * This is intentionally stricter than `/health`: it verifies startup
+ * configuration and performs a lightweight database/schema query against the
+ * shared `site` table through the service layer.
+ */
+export async function getInstanceReadiness(
+  env: Pick<
+    Bindings,
+    | "AUTH_SECRET"
+    | "DB"
+    | "HOSTED_CONTROL_PLANE_BASE_URL"
+    | "HOSTED_CONTROL_PLANE_DOMAIN_CHECK_SECRET"
+    | "HOSTED_CONTROL_PLANE_INTERNAL_BASE_URL"
+    | "HOSTED_CONTROL_PLANE_INTERNAL_TOKEN"
+    | "HOSTED_CONTROL_PLANE_SSO_SECRET"
+    | "INTERNAL_ADMIN_TOKEN"
+    | "NODE_DATABASE"
+    | "NODE_SQLITE"
+    | "SITE_RESOLUTION_MODE"
+  >,
+): Promise<InstanceReadinessResult> {
+  const startupConfig = getStartupConfigurationReadiness(env);
+  const database = await getDatabaseReadiness(env);
+
+  return {
+    status: startupConfig.ok && database.ok ? "ok" : "error",
+    checks: {
+      startupConfig,
+      database,
+    },
+  };
+}

package/src/services/__tests__/collection.test.ts

@@ -117,6 +117,24 @@ describe("CollectionService", () => {
         }),
       ).rejects.toThrow();
     });
+
+    it("rejects aggregate syntax in collection slugs", async () => {
+      await expect(
+        collectionService.create({
+          slug: "smart+movies",
+          title: "Smart + Movies",
+        }),
+      ).rejects.toThrow("Use lowercase letters, numbers, and hyphens only.");
+    });
+
+    it("rejects slugs reserved by the collection namespace", async () => {
+      await expect(
+        collectionService.create({
+          slug: "new",
+          title: "New",
+        }),
+      ).rejects.toThrow("This link is reserved. Choose something else.");
+    });
   });
 
   describe("getById", () => {
@@ -156,6 +174,33 @@ describe("CollectionService", () => {
     });
   });
 
+  describe("resolveSelection", () => {
+    it("resolves, dedupes, and preserves slug order", async () => {
+      await collectionService.create({ slug: "smart", title: "Smart" });
+      await collectionService.create({ slug: "movies", title: "Movies" });
+
+      const selection =
+        await collectionService.resolveSelection("smart+movies+smart");
+
+      expect(selection?.slugs).toEqual(["smart", "movies"]);
+      expect(selection?.slugExpression).toBe("smart+movies");
+      expect(
+        selection?.collections.map((collection) => collection.slug),
+      ).toEqual(["smart", "movies"]);
+    });
+
+    it("returns null when any slug is missing or the expression is malformed", async () => {
+      await collectionService.create({ slug: "smart", title: "Smart" });
+
+      await expect(
+        collectionService.resolveSelection("smart++movies"),
+      ).resolves.toBeNull();
+      await expect(
+        collectionService.resolveSelection("smart+missing"),
+      ).resolves.toBeNull();
+    });
+  });
+
   describe("list", () => {
     it("returns empty array when no collections exist", async () => {
       const list = await collectionService.list();

package/src/services/__tests__/post-timeline.test.ts

@@ -503,5 +503,63 @@ describe("PostService - Timeline features", () => {
       expect(entries[1]?.post.id).toBe(firstRoot.id);
       expect(entries[1]?.collectedAt).toBe(100);
     });
+
+    it("dedupes shared threads across multiple collections", async () => {
+      const smart = await collectionService.create({
+        slug: "smart",
+        title: "Smart",
+      });
+      const movies = await collectionService.create({
+        slug: "movies",
+        title: "Movies",
+      });
+      const sharedRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Shared root",
+      });
+      const sharedReply = await postService.create({
+        format: "note",
+        bodyMarkdown: "Shared reply",
+        replyToId: sharedRoot.id,
+      });
+      const secondRoot = await postService.create({
+        format: "note",
+        bodyMarkdown: "Second root",
+      });
+
+      await db.insert(postCollections).values([
+        {
+          siteId: DEFAULT_TEST_SITE_ID,
+          postId: sharedRoot.id,
+          collectionId: smart.id,
+          createdAt: 100,
+        },
+        {
+          siteId: DEFAULT_TEST_SITE_ID,
+          postId: sharedReply.id,
+          collectionId: movies.id,
+          createdAt: 300,
+        },
+        {
+          siteId: DEFAULT_TEST_SITE_ID,
+          postId: secondRoot.id,
+          collectionId: movies.id,
+          createdAt: 200,
+        },
+      ]);
+
+      const entries = await postService.listCollectionFeedEntriesForCollections(
+        [smart.id, movies.id],
+        {
+          status: "published",
+        },
+      );
+
+      expect(entries).toHaveLength(2);
+      expect(entries[0]?.post.id).toBe(sharedRoot.id);
+      expect(entries[0]?.collectedAt).toBe(300);
+      expect(entries[1]?.post.id).toBe(secondRoot.id);
+      expect(entries[1]?.collectedAt).toBe(200);
+    });
   });
 });

package/src/services/__tests__/post.test.ts

@@ -4,7 +4,7 @@ import {
   createTestDatabase,
   DEFAULT_TEST_SITE_ID,
 } from "../../__tests__/helpers/db.js";
-import { posts } from "../../db/schema.js";
+import { postCollections, posts } from "../../db/schema.js";
 import { createPostService } from "../post.js";
 import { createMediaService } from "../media.js";
 import { createCollectionService } from "../collection.js";
@@ -903,6 +903,40 @@ describe("PostService", () => {
       const count = await postService.count({ excludeReplies: true });
       expect(count).toBe(1);
     });
+
+    it("can stop counting after a small limit", async () => {
+      const collection = await collectionService.create({
+        slug: "rated",
+        title: "Rated",
+      });
+
+      for (let i = 0; i < 3; i++) {
+        const post = await postService.create({
+          format: "link",
+          title: `rated ${i}`,
+          url: `https://example.com/${i}`,
+          rating: i + 1,
+        });
+
+        await db.insert(postCollections).values({
+          siteId: DEFAULT_TEST_SITE_ID,
+          postId: post.id,
+          collectionId: collection.id,
+          createdAt: 100 + i,
+        });
+      }
+
+      const count = await postService.countUpTo(
+        {
+          collectionIds: [collection.id],
+          status: "published",
+          hasRating: true,
+        },
+        2,
+      );
+
+      expect(count).toBe(2);
+    });
   });
 
   describe("countByYearMonth", () => {

package/src/services/collection.ts

@@ -64,9 +64,39 @@ function isUniqueConstraintError(err: unknown): boolean {
   return false;
 }
 
+export interface ResolvedCollectionSelection {
+  collections: Collection[];
+  slugs: string[];
+  slugExpression: string;
+}
+
+function parseCollectionSelectionSlugs(
+  slugExpression: string,
+): string[] | null {
+  const parts = slugExpression.split("+");
+  if (parts.length === 0) return null;
+
+  const seen = new Set<string>();
+  const slugs: string[] = [];
+
+  for (const part of parts) {
+    const slug = part.trim();
+    if (!slug) return null;
+    if (seen.has(slug)) continue;
+    seen.add(slug);
+    slugs.push(slug);
+  }
+
+  return slugs.length > 0 ? slugs : null;
+}
+
 export interface CollectionService {
   getById(id: string): Promise<Collection | null>;
   getBySlug(slug: string): Promise<Collection | null>;
+  getBySlugs(slugs: string[]): Promise<Collection[]>;
+  resolveSelection(
+    slugExpression: string,
+  ): Promise<ResolvedCollectionSelection | null>;
   list(): Promise<Collection[]>;
   listDirectoryData(): Promise<CollectionsDirectoryData>;
   /** List collections sorted by most recent post addition (for compose dialog) */
@@ -430,6 +460,31 @@ export function createCollectionService(
       return this.getById(resolved.collectionId);
     },
 
+    async getBySlugs(slugs) {
+      if (slugs.length === 0) return [];
+
+      const collections = await Promise.all(
+        slugs.map((slug) => this.getBySlug(slug)),
+      );
+      return collections.filter(
+        (collection): collection is Collection => collection !== null,
+      );
+    },
+
+    async resolveSelection(slugExpression) {
+      const slugs = parseCollectionSelectionSlugs(slugExpression);
+      if (!slugs) return null;
+
+      const collections = await this.getBySlugs(slugs);
+      if (collections.length !== slugs.length) return null;
+
+      return {
+        collections,
+        slugs,
+        slugExpression: slugs.join("+"),
+      };
+    },
+
     async list() {
       const rows = await db
         .select()

package/src/services/post.ts

@@ -83,6 +83,7 @@ export interface PostFilters {
   pinned?: boolean;
   featured?: boolean;
   collectionId?: string;
+  collectionIds?: string[];
   /** Exclude posts that are replies (have replyToId set) */
   excludeReplies?: boolean;
   /** Exclude posts hidden from Latest from results */
@@ -150,6 +151,8 @@ export interface PostService {
   list(filters?: PostFilters): Promise<Post[]>;
   /** Count posts matching filters (ignores cursor, offset, limit) */
   count(filters?: PostFilters): Promise<number>;
+  /** Count posts matching filters up to a fixed limit (ignores cursor, offset, limit) */
+  countUpTo(filters: PostFilters | undefined, limit: number): Promise<number>;
   /** Count posts grouped by published year-month (YYYY-MM) */
   countByYearMonth(
     filters?: PostFilters,
@@ -207,16 +210,31 @@ export interface PostService {
     collectionId: string,
     options?: ThreadRootPageOptions,
   ): Promise<number>;
+  /** Count distinct thread roots that contain published posts in any of the given collections */
+  countCollectionThreadRootsForCollections(
+    collectionIds: string[],
+    options?: ThreadRootPageOptions,
+  ): Promise<number>;
   /** List collection thread root IDs ordered by collected-at or rating semantics */
   listCollectionThreadRootIds(
     collectionId: string,
     options?: CollectionThreadRootPageOptions,
   ): Promise<string[]>;
+  /** List collection thread root IDs for a union of collections */
+  listCollectionThreadRootIdsForCollections(
+    collectionIds: string[],
+    options?: CollectionThreadRootPageOptions,
+  ): Promise<string[]>;
   /** List collection feed entries ordered by latest added-at timestamp */
   listCollectionFeedEntries(
     collectionId: string,
     options?: ThreadRootPageOptions,
   ): Promise<CollectionFeedEntry[]>;
+  /** List collection feed entries for a union of collections */
+  listCollectionFeedEntriesForCollections(
+    collectionIds: string[],
+    options?: ThreadRootPageOptions,
+  ): Promise<CollectionFeedEntry[]>;
   /** Fetch all published, non-deleted posts for each requested thread root */
   getPublishedThreads(rootIds: string[]): Promise<Map<string, Post[]>>;
   /** For each thread, return post IDs that belong to the given collection */
@@ -224,6 +242,11 @@ export interface PostService {
     collectionId: string,
     threadIds: string[],
   ): Promise<Map<string, string[]>>;
+  /** For each thread, return post IDs that belong to any of the given collections */
+  getCollectionPostIdsByThreadForCollections(
+    collectionIds: string[],
+    threadIds: string[],
+  ): Promise<Map<string, string[]>>;
   /** Get distinct years that have published posts */
   getDistinctYears(filters?: PostFilters): Promise<number[]>;
   /** For each thread ID, return the ID of the last published, non-deleted post */
@@ -470,6 +493,43 @@ export function createPostService(
       .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)));
   }
 
+  function normalizeCollectionIds(collectionIds: readonly string[]): string[] {
+    return [...new Set(collectionIds)];
+  }
+
+  function buildCollectionMembershipCondition(
+    collectionIds: readonly string[],
+  ): SQL<unknown> {
+    const uniqueCollectionIds = normalizeCollectionIds(collectionIds);
+    const firstCollectionId = uniqueCollectionIds[0];
+    if (!firstCollectionId) {
+      return sql`0 = 1`;
+    }
+
+    return uniqueCollectionIds.length === 1
+      ? eq(postCollections.collectionId, firstCollectionId)
+      : inArray(postCollections.collectionId, uniqueCollectionIds);
+  }
+
+  function buildPostCollectionSubqueryCondition(
+    collectionIds: readonly string[],
+  ): SQL<unknown> {
+    const uniqueCollectionIds = normalizeCollectionIds(collectionIds);
+    if (uniqueCollectionIds.length === 0) {
+      return sql`0 = 1`;
+    }
+
+    const placeholders = uniqueCollectionIds.map(
+      (collectionId) => sql`${collectionId}`,
+    );
+    return sql`${posts.id} IN (
+      SELECT post_id
+      FROM post_collection
+      WHERE site_id = ${siteId}
+        AND collection_id IN (${sql.join(placeholders, sql`, `)})
+    )`;
+  }
+
   /** Build WHERE conditions from filters (shared by list and count) */
   function buildFilterConditions(filters: PostFilters) {
     const conditions = [eq(posts.siteId, siteId)];
@@ -503,15 +563,13 @@ export function createPostService(
     if (filters.format) {
       conditions.push(eq(posts.format, filters.format));
     }
-    if (filters.collectionId !== undefined) {
-      // Filter by collection via junction table
+    if (filters.collectionIds !== undefined) {
       conditions.push(
-        sql`${posts.id} IN (
-          SELECT post_id
-          FROM post_collection
-          WHERE site_id = ${siteId}
-            AND collection_id = ${filters.collectionId}
-        )`,
+        buildPostCollectionSubqueryCondition(filters.collectionIds),
+      );
+    } else if (filters.collectionId !== undefined) {
+      conditions.push(
+        buildPostCollectionSubqueryCondition([filters.collectionId]),
       );
     }
     if (filters.threadId) {
@@ -1069,6 +1127,22 @@ export function createPostService(
       return result[0]?.count ?? 0;
     },
 
+    async countUpTo(filters = {}, limit) {
+      const normalizedLimit = Math.max(0, Math.trunc(limit));
+      if (normalizedLimit === 0) {
+        return 0;
+      }
+
+      const conditions = buildFilterConditions(filters);
+      const rows = await db
+        .select({ id: posts.id })
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .limit(normalizedLimit);
+
+      return rows.length;
+    },
+
     async countByYearMonth(filters = {}) {
       const conditions = [
         ...buildFilterConditions(filters),
@@ -2150,9 +2224,19 @@ export function createPostService(
     },
 
     async countCollectionThreadRoots(collectionId, options = {}) {
+      return this.countCollectionThreadRootsForCollections(
+        [collectionId],
+        options,
+      );
+    },
+
+    async countCollectionThreadRootsForCollections(
+      collectionIds,
+      options = {},
+    ) {
       const conditions = [
         ...buildThreadRootPageConditions(options),
-        eq(postCollections.collectionId, collectionId),
+        buildCollectionMembershipCondition(collectionIds),
       ];
 
       const rows = await db
@@ -2173,9 +2257,19 @@ export function createPostService(
     },
 
     async listCollectionThreadRootIds(collectionId, options = {}) {
+      return this.listCollectionThreadRootIdsForCollections(
+        [collectionId],
+        options,
+      );
+    },
+
+    async listCollectionThreadRootIdsForCollections(
+      collectionIds,
+      options = {},
+    ) {
       const conditions = [
         ...buildThreadRootPageConditions(options),
-        eq(postCollections.collectionId, collectionId),
+        buildCollectionMembershipCondition(collectionIds),
       ];
       const sortOrder = options.sortOrder ?? "newest";
       const collectedAt =
@@ -2234,9 +2328,16 @@ export function createPostService(
     },
 
     async listCollectionFeedEntries(collectionId, options = {}) {
+      return this.listCollectionFeedEntriesForCollections(
+        [collectionId],
+        options,
+      );
+    },
+
+    async listCollectionFeedEntriesForCollections(collectionIds, options = {}) {
       const conditions = [
         ...buildThreadRootPageConditions(options),
-        eq(postCollections.collectionId, collectionId),
+        buildCollectionMembershipCondition(collectionIds),
       ];
       const collectedAt = sql<number>`MAX(${postCollections.createdAt})`.as(
         "collected_at",
@@ -2306,6 +2407,13 @@ export function createPostService(
     },
 
     async getCollectionPostIdsByThread(collectionId, threadIds) {
+      return this.getCollectionPostIdsByThreadForCollections(
+        [collectionId],
+        threadIds,
+      );
+    },
+
+    async getCollectionPostIdsByThreadForCollections(collectionIds, threadIds) {
       const result = new Map<string, string[]>();
       if (threadIds.length === 0) return result;
 
@@ -2327,12 +2435,13 @@ export function createPostService(
           .where(
             and(
               eq(posts.siteId, siteId),
-              eq(postCollections.collectionId, collectionId),
+              buildCollectionMembershipCondition(collectionIds),
               inArray(posts.threadId, chunk),
               eq(posts.status, "published"),
               isNull(posts.deletedAt),
             ),
           )
+          .groupBy(posts.threadId, posts.id)
           .orderBy(posts.threadId, posts.createdAt, posts.id),
       );
 

package/src/styles/ui.css

@@ -754,6 +754,23 @@
     color: var(--site-text-secondary);
   }
 
+  .collection-directory-divider-link {
+    color: inherit;
+    text-decoration: none;
+    transition:
+      color 160ms ease,
+      text-decoration-color 160ms ease;
+    text-decoration-color: transparent;
+  }
+
+  .collection-directory-divider-link:hover,
+  .collection-directory-divider-link:focus-visible {
+    color: var(--foreground);
+    text-decoration: underline;
+    text-decoration-color: currentColor;
+    text-underline-offset: 0.18em;
+  }
+
   .collection-directory-divider-line {
     flex: 1;
     height: 1px;

package/src/types/props.ts

@@ -87,11 +87,12 @@ export interface SearchPageProps {
 
 /** Props for the single collection page component */
 export interface CollectionPageProps {
-  collection: Collection;
+  collections: Collection[];
   items: TimelineItemView[];
   totalThreadCount: number;
   currentPage: number;
   totalPages: number;
+  pagePath: string;
   baseUrl: string;
   currentSort: CollectionSortOrder;
   defaultSort: CollectionSortOrder;