@kombo-api/sdk 0.2.3 → 0.3.2

package/tests/basic-behavior.spec.ts

@@ -1,7 +1,6 @@
-import { it, expect } from "vitest";
+import { it, expect, describe } from "vitest";
 import { TestContext, describeSdkSuite } from "./helpers/test-context";
 
-// TODO: test basic error handling behavior
 describeSdkSuite("Basic SDK Behavior", () => {
   it("should include API key in Authorization header", async () => {
     const ctx = new TestContext({ apiKey: "my-custom-api-key" });
@@ -159,4 +158,358 @@ describeSdkSuite("Basic SDK Behavior", () => {
     const requestWithoutDeleted = ctx.getLastRequest();
     expect(requestWithoutDeleted.path).toContain("include_deleted=false");
   });
+
+  describe("Pagination Behavior", () => {
+    it("should iterate through multiple pages", async () => {
+      const ctx = new TestContext();
+
+      // Mock 3 pages of results
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag1",
+                  remote_id: null,
+                  name: "Tag 1",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+                {
+                  id: "tag2",
+                  remote_id: null,
+                  name: "Tag 2",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: "cursor_page2",
+            },
+          },
+        },
+      });
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag3",
+                  remote_id: null,
+                  name: "Tag 3",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+                {
+                  id: "tag4",
+                  remote_id: null,
+                  name: "Tag 4",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: "cursor_page3",
+            },
+          },
+        },
+      });
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag5",
+                  remote_id: null,
+                  name: "Tag 5",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: null,
+            },
+          },
+        },
+      });
+
+      const tags = await ctx.kombo.ats.getTags({});
+      const allResults: unknown[] = [];
+
+      for await (const page of tags) {
+        allResults.push(...page.result.data.results);
+      }
+
+      // Verify all 5 tags were collected
+      expect(allResults).toHaveLength(5);
+      expect(allResults.map((r: any) => r.id)).toEqual([
+        "tag1",
+        "tag2",
+        "tag3",
+        "tag4",
+        "tag5",
+      ]);
+
+      // Verify 3 HTTP requests were made
+      const requests = ctx.getRequests();
+      expect(requests).toHaveLength(3);
+    });
+
+    it("should pass cursor parameter to subsequent requests", async () => {
+      const ctx = new TestContext();
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag1",
+                  remote_id: null,
+                  name: "Tag 1",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: "test_cursor_abc123",
+            },
+          },
+        },
+      });
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag2",
+                  remote_id: null,
+                  name: "Tag 2",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: null,
+            },
+          },
+        },
+      });
+
+      const tags = await ctx.kombo.ats.getTags({});
+      for await (const _page of tags) {
+        // Iterate through all pages
+      }
+
+      const requests = ctx.getRequests();
+      expect(requests).toHaveLength(2);
+
+      // First request should NOT include cursor
+      expect(requests[0].path).not.toContain("cursor=");
+
+      // Second request SHOULD include cursor
+      expect(requests[1].path).toContain("cursor=test_cursor_abc123");
+    });
+
+    it("should stop pagination when next is null", async () => {
+      const ctx = new TestContext();
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag1",
+                  remote_id: null,
+                  name: "Tag 1",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+                {
+                  id: "tag2",
+                  remote_id: null,
+                  name: "Tag 2",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: null,
+            },
+          },
+        },
+      });
+
+      const tags = await ctx.kombo.ats.getTags({});
+      const pageCount: number[] = [];
+
+      for await (const _page of tags) {
+        pageCount.push(1);
+      }
+
+      // Verify only 1 page was returned
+      expect(pageCount).toHaveLength(1);
+
+      // Verify only 1 HTTP request was made
+      const requests = ctx.getRequests();
+      expect(requests).toHaveLength(1);
+    });
+
+    it("should preserve query parameters across paginated requests", async () => {
+      const ctx = new TestContext();
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag1",
+                  remote_id: null,
+                  name: "Tag 1",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: "cursor_for_page2",
+            },
+          },
+        },
+      });
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag2",
+                  remote_id: null,
+                  name: "Tag 2",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: null,
+            },
+          },
+        },
+      });
+
+      const tags = await ctx.kombo.ats.getTags({
+        updated_after: new Date("2024-01-01T00:00:00.000Z"),
+      });
+
+      for await (const _page of tags) {
+        // Iterate through all pages
+      }
+
+      const requests = ctx.getRequests();
+      expect(requests).toHaveLength(2);
+
+      // Both requests should include the original query parameters
+      // Check that updated_after parameter is present (URL encoded)
+      expect(requests[0].path).toMatch(/updated_after=2024-01-01T00%3A00%3A00\.000Z/);
+      expect(requests[0].path).not.toContain("cursor=");
+
+      expect(requests[1].path).toMatch(/updated_after=2024-01-01T00%3A00%3A00\.000Z/);
+      expect(requests[1].path).toContain("cursor=cursor_for_page2");
+    });
+
+    it("should support manual pagination with next()", async () => {
+      const ctx = new TestContext();
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag1",
+                  remote_id: null,
+                  name: "Tag 1",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: "manual_cursor_xyz",
+            },
+          },
+        },
+      });
+
+      ctx.mockEndpoint({
+        method: "GET",
+        path: "/v1/ats/tags",
+        response: {
+          body: {
+            status: "success",
+            data: {
+              results: [
+                {
+                  id: "tag2",
+                  remote_id: null,
+                  name: "Tag 2",
+                  changed_at: "2024-01-01T00:00:00.000Z",
+                  remote_deleted_at: null,
+                },
+              ],
+              next: null,
+            },
+          },
+        },
+      });
+
+      const page1 = await ctx.kombo.ats.getTags({});
+      
+      // Verify first page was fetched
+      expect(page1.result.data.results).toBeDefined();
+      expect(page1.result.data.results).toHaveLength(1);
+
+      // Manually call next()
+      const page2Result = await page1.next();
+      
+      // Verify second page was fetched (should not be null if cursor was read correctly)
+      // This will fail if cursor extraction bug exists
+      expect(page2Result).not.toBeNull();
+      if (page2Result) {
+        expect(page2Result.result.data.results).toHaveLength(1);
+        expect(page2Result.result.data.results[0].id).toBe("tag2");
+      }
+
+      // Verify 2 HTTP requests were made
+      const requests = ctx.getRequests();
+      expect(requests).toHaveLength(2);
+      expect(requests[1].path).toContain("cursor=manual_cursor_xyz");
+    });
+  });
 });

package/tests/helpers/test-context.ts

@@ -1,4 +1,4 @@
-import { describe, beforeAll, afterAll } from "vitest";
+import { describe, beforeAll, afterAll, afterEach } from "vitest";
 import nock from "nock";
 import { Kombo } from "../../src/index";
 
@@ -137,8 +137,11 @@ export function describeSdkSuite(name: string, fn: () => void) {
       nock.disableNetConnect();
     });
 
-    afterAll(() => {
+    afterEach(() => {
       nock.cleanAll();
+    });
+
+    afterAll(() => {
       nock.enableNetConnect();
     });
 

package/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "compilerOptions": {
-    "incremental": true,
-    "tsBuildInfoFile": ".tsbuildinfo",
+    "incremental": false,
     "target": "ES2020",
     "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "jsx": "react-jsx",