Page the per-tenant SEO feed at the bridge's own limit

apps/self-hosted/hosting/api/src/services/seo-files.test.ts

@@ -122,6 +122,11 @@ describe('fetchTenantPosts', () => {
       undefined,
       expect.any(AbortSignal),
     );
+    // The bridge asserts limit into [1:20] and ERRORS above it, so a page may
+    // never ask for more; asking for 100 failed every tenant in production.
+    for (const call of mocks.callRPC.mock.calls) {
+      expect(call[1].limit).toBeLessThanOrEqual(20);
+    }
 
     const community = {
       ...TENANT,
@@ -141,6 +146,57 @@ describe('fetchTenantPosts', () => {
     );
   });
 
+  it('walks pages with an exclusive cursor up to the wanted depth', async () => {
+    // Six full pages exist; the walk wants 100 posts, so it stops after five.
+    const page = (n: number) =>
+      Array.from({ length: 20 }, (_, i) => ({
+        author: 'alice',
+        permlink: `p${n}-${i}`,
+        created: '2026-08-01T00:00:00',
+      }));
+    mocks.callRPC.mockImplementation(async (_m: string, params: any) =>
+      page(Number(params.start_permlink?.split('-')[0]?.replace('p', '') ?? -1) + 1),
+    );
+
+    const posts = await fetchTenantPosts(TENANT);
+    expect(posts).toHaveLength(100);
+    expect(mocks.callRPC).toHaveBeenCalledTimes(5);
+    // Each page after the first carries the previous page's last post as the
+    // cursor, and every returned post is distinct.
+    expect(mocks.callRPC.mock.calls[1][1]).toMatchObject({
+      start_author: 'alice',
+      start_permlink: 'p0-19',
+    });
+    expect(new Set(posts.map((p) => p.permlink)).size).toBe(100);
+  });
+
+  it('stops on a short page instead of asking for one more', async () => {
+    mocks.callRPC.mockResolvedValue(
+      Array.from({ length: 3 }, (_, i) => ({
+        author: 'alice',
+        permlink: `only-${i}`,
+        created: '2026-08-01T00:00:00',
+      })),
+    );
+    const posts = await fetchTenantPosts(TENANT);
+    expect(posts).toHaveLength(3);
+    expect(mocks.callRPC).toHaveBeenCalledTimes(1);
+  });
+
+  it('terminates when a node echoes the cursor post back forever', async () => {
+    // An inclusive-cursor node would otherwise repeat its last page for ever:
+    // a full page whose posts are all already seen ends the walk.
+    const repeated = Array.from({ length: 20 }, (_, i) => ({
+      author: 'alice',
+      permlink: `same-${i}`,
+      created: '2026-08-01T00:00:00',
+    }));
+    mocks.callRPC.mockResolvedValue(repeated);
+    const posts = await fetchTenantPosts(TENANT);
+    expect(posts).toHaveLength(20);
+    expect(mocks.callRPC).toHaveBeenCalledTimes(2);
+  });
+
   it('throws on a malformed response so stale files are kept, never blanked', async () => {
     mocks.callRPC.mockResolvedValue({ nope: true });
     await expect(fetchTenantPosts(TENANT)).rejects.toThrow('malformed');

apps/self-hosted/hosting/api/src/services/seo-files.ts

@@ -43,8 +43,19 @@ export function canonicalPostUrl(
   return `https://ecency.com/@${author}/${permlink}`;
 }
 
-/** How many posts feeds and sitemaps carry; one bridge page. */
+/**
+ * How many posts feeds and sitemaps carry, and how they are collected.
+ *
+ * The bridge asserts `limit` into [1:20] and answers an ERROR, not a shorter
+ * list, when asked for more: a single limit=100 call failed every tenant's
+ * pass in production, so the wanted depth is PAGED at the bridge's own page
+ * size. The whole walk carries one deadline as well as the per-call one, so
+ * a chain that answers slowly costs a bounded pass rather than page count
+ * times the per-call timeout.
+ */
 const POST_LIMIT = 100;
+const BRIDGE_PAGE_LIMIT = 20;
+const FETCH_BUDGET_MS = 30_000;
 /** A pass regenerates a tenant's files only when they are older than this. */
 export const SEO_FRESH_MS = 30 * 60 * 1000;
 /** The background pass is patient but never unbounded. */
@@ -92,45 +103,66 @@ async function boundedCall<T>(method: string, params: object): Promise<T> {
 /** The tenant's latest posts, the same feeds the archive itself pages. */
 export async function fetchTenantPosts(tenant: Tenant): Promise<TenantPost[]> {
   const { community, communityId } = isCommunityTenant(tenant);
-  const raw = community
-    ? await boundedCall<unknown>('bridge.get_ranked_posts', {
-        sort: 'created',
-        tag: communityId,
-        limit: POST_LIMIT,
-        observer: '',
-      })
-    : await boundedCall<unknown>('bridge.get_account_posts', {
-        sort: 'posts',
-        account: tenant.username,
-        limit: POST_LIMIT,
-        observer: '',
-      });
-  // A malformed answer is an ERROR, never an empty blog: returning [] here
-  // would overwrite a good sitemap and feed with empty ones and mark them
-  // fresh, while throwing lets the sync pass keep yesterday's files.
-  if (!Array.isArray(raw)) {
-    throw new Error('malformed bridge feed response');
-  }
-  // Every field the builders touch is type-checked here: a malformed record
-  // (a numeric date, a missing permlink) is dropped or normalized instead of
-  // failing the tenant's whole SEO pass on an .endsWith of a number.
+  const method = community
+    ? 'bridge.get_ranked_posts'
+    : 'bridge.get_account_posts';
+  const feedParams = community
+    ? { sort: 'created', tag: communityId, observer: '' }
+    : { sort: 'posts', account: tenant.username, observer: '' };
+
   const posts: TenantPost[] = [];
-  for (const p of raw as any[]) {
-    if (
-      typeof p?.author !== 'string' ||
-      typeof p?.permlink !== 'string' ||
-      typeof p?.created !== 'string'
-    ) {
-      continue;
-    }
-    posts.push({
-      author: p.author,
-      permlink: p.permlink,
-      title: typeof p.title === 'string' ? p.title : '',
-      created: p.created,
-      updated: typeof p.updated === 'string' ? p.updated : undefined,
-      body: typeof p.body === 'string' ? p.body : undefined,
+  const seen = new Set<string>();
+  const deadline = Date.now() + FETCH_BUDGET_MS;
+  let cursor: { start_author: string; start_permlink: string } | null = null;
+
+  while (posts.length < POST_LIMIT) {
+    const raw = await boundedCall<unknown>(method, {
+      ...feedParams,
+      limit: Math.min(BRIDGE_PAGE_LIMIT, POST_LIMIT - posts.length),
+      ...(cursor ?? {}),
     });
+    // A malformed answer is an ERROR, never an empty blog: returning [] here
+    // would overwrite a good sitemap and feed with empty ones and mark them
+    // fresh, while throwing lets the sync pass keep yesterday's files.
+    if (!Array.isArray(raw)) {
+      throw new Error('malformed bridge feed response');
+    }
+    const page = raw as any[];
+    // Every field the builders touch is type-checked here: a malformed record
+    // (a numeric date, a missing permlink) is dropped or normalized instead of
+    // failing the tenant's whole SEO pass on an .endsWith of a number.
+    let added = 0;
+    let last: { author: string; permlink: string } | null = null;
+    for (const p of page) {
+      if (
+        typeof p?.author !== 'string' ||
+        typeof p?.permlink !== 'string' ||
+        typeof p?.created !== 'string'
+      ) {
+        continue;
+      }
+      last = { author: p.author, permlink: p.permlink };
+      // The cursor is exclusive on today's bridge, but a node that echoes the
+      // start post back would otherwise repeat a page forever; the identity
+      // set makes the walk terminate either way.
+      const key = `${p.author}/${p.permlink}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      added++;
+      posts.push({
+        author: p.author,
+        permlink: p.permlink,
+        title: typeof p.title === 'string' ? p.title : '',
+        created: p.created,
+        updated: typeof p.updated === 'string' ? p.updated : undefined,
+        body: typeof p.body === 'string' ? p.body : undefined,
+      });
+    }
+    // A short page is the end of the feed; no new posts or no usable record
+    // means paging further cannot help. Either way, stop.
+    if (page.length < BRIDGE_PAGE_LIMIT || added === 0 || !last) break;
+    if (Date.now() >= deadline) break;
+    cursor = { start_author: last.author, start_permlink: last.permlink };
   }
   return posts;
 }