@unito/integration-sdk 2.4.4 → 3.0.1

package/dist/test/resources/provider.test.js

@@ -42,7 +42,7 @@ describe('Provider', () => {
     it('get', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
@@ -66,12 +66,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('accepts text/html type response', async (context) => {
         const response = new Response('', {
             status: 200,
-            headers: { 'Content-Type': 'text/html; charset=UTF-8' },
+            headers: new Headers({ 'Content-Type': 'text/html; charset=UTF-8' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
@@ -95,12 +99,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: '' });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: '',
+        });
     });
     it('accepts application/schema+json type response', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
-            headers: { 'Content-Type': 'application/schema+json; charset=UTF-8' },
+            headers: new Headers({ 'Content-Type': 'application/schema+json; charset=UTF-8' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
@@ -124,12 +132,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('accepts application/swagger+json type response', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
-            headers: { 'Content-Type': 'application/swagger+json; charset=UTF-8' },
+            headers: new Headers({ 'Content-Type': 'application/swagger+json; charset=UTF-8' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
@@ -153,12 +165,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('accepts application/vnd.oracle.resource+json type response', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
-            headers: { 'Content-Type': 'application/vnd.oracle.resource+json; type=collection; charset=UTF-8' },
+            headers: new Headers({ 'Content-Type': 'application/vnd.oracle.resource+json; type=collection; charset=UTF-8' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('/endpoint', {
@@ -182,12 +198,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('returns the raw response body if specified', async (context) => {
         const response = new Response(`IMAGINE A HUGE PAYLOAD`, {
             status: 200,
-            headers: { 'Content-Type': 'image/png' },
+            headers: new Headers({ 'Content-Type': 'image/png' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.streamingGet('/endpoint/123', {
@@ -206,7 +226,7 @@ describe('Provider', () => {
     it('gets an endpoint which is an absolute url', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('https://my-cdn.my-domain.com/file.png', {
@@ -228,12 +248,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('gets on provider url', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 200,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.get('', {
@@ -255,12 +279,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('post with url encoded body', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 201,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.post('/endpoint', {
@@ -287,12 +315,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 201,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('accepts an array as body for post request', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 201,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.post('/endpoint', [
@@ -320,12 +352,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 201,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('put with json body', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 201,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         // Removing leading '/' on endpoint to make sure we support both cases
@@ -353,12 +389,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 201,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('putBuffer with Buffer body', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 201,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const buffer = Buffer.from('binary data content');
@@ -385,12 +425,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 201,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('patch with query params', async (context) => {
         const response = new Response('{"data": "value"}', {
             status: 201,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.patch('/endpoint/123', {
@@ -418,12 +462,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 201, headers: response.headers, body: { data: 'value' } });
+        assert.deepEqual(actualResponse, {
+            status: 201,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { data: 'value' },
+        });
     });
     it('delete', async (context) => {
         const response = new Response(undefined, {
             status: 204,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const actualResponse = await provider.delete('/endpoint/123', {
@@ -447,12 +495,16 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 204, headers: response.headers, body: undefined });
+        assert.deepEqual(actualResponse, {
+            status: 204,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: undefined,
+        });
     });
     it('deleteWithBody', async (context) => {
         const response = new Response('{"success": true}', {
             status: 200,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const requestBody = { webhookIds: [1, 2, 3] };
@@ -478,7 +530,11 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 200, headers: response.headers, body: { success: true } });
+        assert.deepEqual(actualResponse, {
+            status: 200,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: { success: true },
+        });
     });
     it('uses rate limiter if provided', async (context) => {
         const mockRateLimiter = context.mock.fn((_context, request) => Promise.resolve(request()));
@@ -496,7 +552,7 @@ describe('Provider', () => {
         });
         const response = new Response(undefined, {
             status: 204,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         const fetchMock = context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
@@ -523,7 +579,11 @@ describe('Provider', () => {
                 },
             },
         ]);
-        assert.deepEqual(actualResponse, { status: 204, headers: response.headers, body: undefined });
+        assert.deepEqual(actualResponse, {
+            status: 204,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: undefined,
+        });
     });
     it('uses custom error handler if provided', async (context) => {
         const rateLimitedProvider = new Provider({
@@ -542,7 +602,7 @@ describe('Provider', () => {
         });
         const response = new Response(undefined, {
             status: 400,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
@@ -583,7 +643,7 @@ describe('Provider', () => {
         });
         const response = new Response(undefined, {
             status: 400,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
@@ -619,7 +679,7 @@ describe('Provider', () => {
         });
         const response = new Response(undefined, {
             status: 404,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const options = {
@@ -641,7 +701,7 @@ describe('Provider', () => {
     it('returns valid json response', async (context) => {
         const response = new Response(`{ "validJson": true }`, {
             status: 200,
-            headers: { 'Content-Type': 'application/json;charset=utf-8' },
+            headers: new Headers({ 'Content-Type': 'application/json;charset=utf-8' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.get('/endpoint/123', {
@@ -669,7 +729,7 @@ describe('Provider', () => {
     it('returns streamable response on streaming get calls', async (context) => {
         const response = new Response(`IMAGINE A HUGE PAYLOAD`, {
             status: 200,
-            headers: { 'Content-Type': 'video/mp4' },
+            headers: new Headers({ 'Content-Type': 'video/mp4' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.streamingGet('/endpoint/123', {
@@ -683,7 +743,7 @@ describe('Provider', () => {
     it('returns successfully on unexpected content-type response with no body', async (context) => {
         const response = new Response(null, {
             status: 201,
-            headers: { 'Content-Type': 'html/text' },
+            headers: new Headers({ 'Content-Type': 'html/text' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         const providerResponse = await provider.post('/endpoint/123', {}, {
@@ -693,13 +753,13 @@ describe('Provider', () => {
         });
         assert.ok(providerResponse);
         assert.strictEqual(providerResponse.status, response.status);
-        assert.strictEqual(providerResponse.headers, response.headers);
+        assert.deepEqual(providerResponse.headers, Object.fromEntries(response.headers.entries()));
         assert.strictEqual(providerResponse.body, undefined);
     });
     it('throws on invalid json response', async (context) => {
         const response = new Response('{invalidJSON}', {
             status: 200,
-            headers: { 'Content-Type': 'application/json' },
+            headers: new Headers({ 'Content-Type': 'application/json' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         let error;
@@ -719,7 +779,7 @@ describe('Provider', () => {
     it('throws on unexpected content-type response', async (context) => {
         const response = new Response('text', {
             status: 200,
-            headers: { 'Content-Type': 'application/text' },
+            headers: new Headers({ 'Content-Type': 'application/text' }),
         });
         context.mock.method(global, 'fetch', () => Promise.resolve(response));
         let error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "2.4.4",
+  "version": "3.0.1",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/helpers.ts

@@ -35,3 +35,30 @@ export function getApplicableFilters(context: { filters: Filter[] }, fields: Fie
 
   return applicableFilters;
 }
+
+/**
+ * Use this helper function to build the query params for a collection next page URL.
+ * It re-encodes the parsed filters and selects back into query-param form,
+ * so integrations can easily construct `nextPage` URLs.
+ *
+ * @example
+ * const params = buildCollectionQueryParams({ filters: context.filters, selects: context.selects });
+ * params.append('cursor', nextCursor);
+ * return { info: { nextPage: `/items?${params.toString()}` }, data: [...] };
+ */
+export function buildCollectionQueryParams(params?: { filters?: Filter[]; selects?: string[] }): URLSearchParams {
+  const result = new URLSearchParams();
+
+  if (params?.filters?.length) {
+    result.set(
+      'filter',
+      params.filters.map(f => `${f.field}${f.operator}${(f.values ?? []).map(encodeURIComponent).join('|')}`).join(','),
+    );
+  }
+
+  if (params?.selects?.length) {
+    result.set('select', params.selects.map(encodeURIComponent).join(','));
+  }
+
+  return result;
+}

package/src/index.ts

@@ -14,7 +14,7 @@ export type { Secrets } from './middlewares/secrets.js';
 export type { Credentials } from './middlewares/credentials.js';
 export type { Filter } from './middlewares/filters.js';
 export * as HttpErrors from './httpErrors.js';
-export { getApplicableFilters } from './helpers.js';
+export { buildCollectionQueryParams, getApplicableFilters } from './helpers.js';
 export * from './resources/context.js';
 export { type default as Logger, NULL_LOGGER } from './resources/logger.js';
 /* c8 ignore stop */

package/src/resources/provider.ts

@@ -1,7 +1,6 @@
 import https from 'https';
 import FormData from 'form-data';
 import * as stream from 'stream';
-import { IncomingHttpHeaders } from 'http';
 
 import { buildHttpError } from '../errors.js';
 import * as HttpErrors from '../httpErrors.js';
@@ -57,7 +56,7 @@ export type RequestOptions = {
 export type Response<T> = {
   body: T;
   status: number;
-  headers: Headers | IncomingHttpHeaders;
+  headers: Record<string, string>;
 };
 
 export type PreparedRequest = {
@@ -231,7 +230,15 @@ export class Provider {
                 if (body.error) {
                   reject(this.handleError(400, body.error.message, options));
                 }
-                resolve({ status: 201, headers: response.headers, body });
+                resolve({
+                  status: 201,
+                  headers: Object.fromEntries(
+                    Object.entries(response.headers)
+                      .filter((entry): entry is [string, string | string[]] => entry[1] !== undefined)
+                      .map(([key, value]) => [key, Array.isArray(value) ? value.join(',') : value]),
+                  ),
+                  body,
+                });
               } catch (error) {
                 reject(this.handleError(500, `Failed to parse response body: "${error}"`, options));
               }
@@ -346,7 +353,11 @@ export class Provider {
                 const body = responseBody ? JSON.parse(responseBody) : undefined;
                 safeResolve({
                   status: response.statusCode || 200,
-                  headers: response.headers,
+                  headers: Object.fromEntries(
+                    Object.entries(response.headers)
+                      .filter((entry): entry is [string, string | string[]] => entry[1] !== undefined)
+                      .map(([key, value]) => [key, Array.isArray(value) ? value.join(',') : value]),
+                  ),
                   body,
                 });
               } catch (error) {
@@ -607,7 +618,11 @@ export class Provider {
         throw this.handleError(response.status, textResult, options);
       } else if (response.status === 204 || response.body === null) {
         // No content: return without inspecting the body
-        return { status: response.status, headers: response.headers, body: undefined as unknown as T };
+        return {
+          status: response.status,
+          headers: Object.fromEntries(response.headers.entries()),
+          body: undefined as unknown as T,
+        };
       }
 
       const responseContentType = response.headers.get('content-type');
@@ -642,7 +657,7 @@ export class Provider {
         throw this.handleError(500, 'Unsupported Content-Type', options);
       }
 
-      return { status: response.status, headers: response.headers, body };
+      return { status: response.status, headers: Object.fromEntries(response.headers.entries()), body };
     };
 
     return this.rateLimiter ? this.rateLimiter(options, callToProvider) : callToProvider();

package/test/helpers.test.ts

@@ -2,7 +2,7 @@ import { FieldValueTypes, OperatorTypes, Semantics } from '@unito/integration-ap
 
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import { getApplicableFilters } from '../src/helpers.js';
+import { buildCollectionQueryParams, getApplicableFilters } from '../src/helpers.js';
 
 describe('Helpers', () => {
   describe('getApplicableFilters', () => {
@@ -72,4 +72,113 @@ describe('Helpers', () => {
       assert.deepEqual(actual, []);
     });
   });
+
+  describe('buildCollectionQueryParams', () => {
+    it('encodes a single filter with one value', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['active'] }],
+      });
+      assert.equal(result.get('filter'), 'status=active');
+      assert.equal(result.get('select'), null);
+    });
+
+    it('encodes filter values with special characters', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['foo,bar'] }],
+      });
+      assert.equal(result.get('filter'), 'status=foo%2Cbar');
+    });
+
+    it('encodes filter values containing pipe characters', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'tags', operator: OperatorTypes.EQUAL, values: ['a|b'] }],
+      });
+      assert.equal(result.get('filter'), 'tags=a%7Cb');
+    });
+
+    it('joins multiple values for one filter with |', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['active', 'pending'] }],
+      });
+      assert.equal(result.get('filter'), 'status=active|pending');
+    });
+
+    it('joins multiple filters with ,', () => {
+      const result = buildCollectionQueryParams({
+        filters: [
+          { field: 'status', operator: OperatorTypes.EQUAL, values: ['active'] },
+          { field: 'name', operator: OperatorTypes.INCLUDE, values: ['john'] },
+        ],
+      });
+      assert.equal(result.get('filter'), 'status=active,name*=john');
+    });
+
+    it('handles IS_NULL operator (no values)', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'status', operator: OperatorTypes.IS_NULL, values: [] }],
+      });
+      assert.equal(result.get('filter'), 'status!!');
+    });
+
+    it('handles IS_NULL operator with undefined values', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'status', operator: OperatorTypes.IS_NULL, values: undefined }],
+      });
+      assert.equal(result.get('filter'), 'status!!');
+    });
+
+    it('handles IS_NOT_NULL operator (no values)', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'assignee', operator: OperatorTypes.IS_NOT_NULL, values: [] }],
+      });
+      assert.equal(result.get('filter'), 'assignee!');
+    });
+
+    it('encodes selects', () => {
+      const result = buildCollectionQueryParams({
+        selects: ['name', 'dept.id'],
+      });
+      assert.equal(result.get('select'), 'name,dept.id');
+      assert.equal(result.get('filter'), null);
+    });
+
+    it('encodes selects with special characters', () => {
+      const result = buildCollectionQueryParams({
+        selects: ['field with spaces'],
+      });
+      assert.equal(result.get('select'), 'field%20with%20spaces');
+    });
+
+    it('encodes both filters and selects', () => {
+      const result = buildCollectionQueryParams({
+        filters: [{ field: 'status', operator: OperatorTypes.EQUAL, values: ['active'] }],
+        selects: ['name', 'status'],
+      });
+      assert.equal(result.get('filter'), 'status=active');
+      assert.equal(result.get('select'), 'name,status');
+    });
+
+    it('returns empty URLSearchParams when called with no arguments', () => {
+      const result = buildCollectionQueryParams();
+      assert.equal(result.toString(), '');
+    });
+
+    it('omits filter key for empty filters array', () => {
+      const result = buildCollectionQueryParams({ filters: [] });
+      assert.equal(result.get('filter'), null);
+    });
+
+    it('omits select key for empty selects array', () => {
+      const result = buildCollectionQueryParams({ selects: [] });
+      assert.equal(result.get('select'), null);
+    });
+
+    it('can be extended with additional params (e.g. cursor)', () => {
+      const result = buildCollectionQueryParams({
+        selects: ['name'],
+      });
+      result.append('cursor', 'abc123');
+      assert.equal(result.toString(), 'select=name&cursor=abc123');
+    });
+  });
 });