@myapihq/cli 2.20.0 → 2.20.1

package/dist/sdk-request-all.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk-request-all.test.js

@@ -0,0 +1,94 @@
+// requestAll follows a keyset cursor to the end.
+//
+// The backend started paging ten list endpoints on 2026-08-20. Callers using
+// `request` kept working and quietly began receiving only the first page — 50
+// rows where they used to get the collection, with nothing in the response
+// saying so. A list that silently stops is worse than a slow one: the caller
+// acts on a partial answer believing it is complete.
+//
+// So these pin the two ways this helper could reintroduce that: stopping early,
+// and looping forever on a server that never says it is done.
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { requestAll } from '@myapihq/sdk';
+/** A stub that pages `rows` and records every URL it was asked for. */
+function pagingServer(rows, pageSize) {
+    const seen = [];
+    const fetchMock = vi.fn(async (url) => {
+        seen.push(url);
+        const u = new URL(url);
+        const cursor = u.searchParams.get('cursor');
+        const start = cursor ? rows.findIndex(r => r.id === cursor) + 1 : 0;
+        const slice = rows.slice(start, start + pageSize);
+        const last = start + pageSize >= rows.length;
+        return new Response(JSON.stringify({
+            success: true,
+            data: slice,
+            error: null,
+            meta: last ? { has_more: false } : { has_more: true, next_cursor: slice[slice.length - 1]?.id },
+        }), { status: 200, headers: { 'content-type': 'application/json' } });
+    });
+    vi.stubGlobal('fetch', fetchMock);
+    return { seen };
+}
+afterEach(() => vi.unstubAllGlobals());
+describe('requestAll', () => {
+    it('returns every row across pages, in order, exactly once', async () => {
+        const rows = Array.from({ length: 23 }, (_, i) => ({ id: `r${i}` }));
+        pagingServer(rows, 5);
+        const got = await requestAll('https://api.test/things', 'k', { pageSize: 5 });
+        expect(got.map(r => r.id)).toEqual(rows.map(r => r.id));
+        expect(new Set(got.map(r => r.id)).size).toBe(23);
+    });
+    it('passes the cursor on, so it is not just asking page one repeatedly', async () => {
+        const rows = Array.from({ length: 7 }, (_, i) => ({ id: `r${i}` }));
+        const { seen } = pagingServer(rows, 3);
+        await requestAll('https://api.test/things', 'k', { pageSize: 3 });
+        expect(seen).toHaveLength(3);
+        expect(seen[0]).toContain('limit=3');
+        expect(seen[0]).not.toContain('cursor=');
+        expect(seen[1]).toContain('cursor=r2');
+        expect(seen[2]).toContain('cursor=r5');
+    });
+    it('stops on the page that says has_more is false', async () => {
+        const rows = Array.from({ length: 4 }, (_, i) => ({ id: `r${i}` }));
+        const { seen } = pagingServer(rows, 10);
+        const got = await requestAll('https://api.test/things', 'k', { pageSize: 10 });
+        expect(got).toHaveLength(4);
+        expect(seen).toHaveLength(1);
+    });
+    it('throws rather than returning a partial list when the server never finishes', async () => {
+        // A server that always says has_more with a fresh cursor. Returning what
+        // was collected would hand back a truncated list that looks complete —
+        // exactly the failure this helper exists to prevent, so it must fail loudly.
+        let n = 0;
+        vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({
+            success: true, data: [{ id: `x${n}` }], error: null,
+            meta: { has_more: true, next_cursor: `c${n++}` },
+        }), { status: 200, headers: { 'content-type': 'application/json' } })));
+        await expect(requestAll('https://api.test/things', 'k', { maxPages: 5 }))
+            .rejects.toThrow(/pagination_runaway|still reported more rows/);
+    });
+    it('throws when the cursor does not advance', async () => {
+        // A stuck cursor is the ascending/descending mix-up seen from the client
+        // side: the server keeps answering with the same next_cursor, so a naive
+        // loop spins forever on the same rows.
+        vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({
+            success: true, data: [{ id: 'same' }], error: null,
+            meta: { has_more: true, next_cursor: 'stuck' },
+        }), { status: 200, headers: { 'content-type': 'application/json' } })));
+        await expect(requestAll('https://api.test/things', 'k', { maxPages: 50 }))
+            .rejects.toThrow(/pagination_stalled|same cursor twice/);
+    });
+    it('unwraps a wrapped payload when told how', async () => {
+        // {queues: […]}, {clients: […]} — the wrappers kept so paging did not break
+        // existing callers.
+        vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({
+            success: true, data: { queues: [{ id: 'q1' }, { id: 'q2' }] }, error: null,
+            meta: { has_more: false },
+        }), { status: 200, headers: { 'content-type': 'application/json' } })));
+        const got = await requestAll('https://api.test/queues', 'k', {
+            select: d => (d?.queues ?? []),
+        });
+        expect(got.map(r => r.id)).toEqual(['q1', 'q2']);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "2.20.0",
+  "version": "2.20.1",
   "description": "MyAPI command-line interface",
   "repository": {
     "type": "git",
@@ -46,7 +46,7 @@
     "lint:skills:strict": "node scripts/copy-skills.js && node scripts/lint-skills.js --strict"
   },
   "dependencies": {
-    "@myapihq/sdk": "^2.20.0"
+    "@myapihq/sdk": "^2.20.1"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",