@algolia/requester-node-http 4.14.2 → 5.0.0-alpha.3

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/echoRequester';
+export * from './src/createHttpRequester';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC"}

package/dist/requester-node-http.cjs.js

@@ -2,86 +2,91 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var url = require('url');
+var clientCommon = require('@algolia/client-common');
 var http = require('http');
 var https = require('https');
-var URL = require('url');
 
-/* eslint functional/prefer-readonly-type: 0 */
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
+var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
+
+function echoRequester(status = 200) {
+    return clientCommon.createEchoRequester({ getURL: (url$1) => new url.URL(url$1), status });
+}
+
+// Global agents allow us to reuse the TCP protocol with multiple clients
 const agentOptions = { keepAlive: true };
-const defaultHttpAgent = new http.Agent(agentOptions);
-const defaultHttpsAgent = new https.Agent(agentOptions);
-function createNodeHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions = {}, } = {}) {
+const defaultHttpAgent = new http__default["default"].Agent(agentOptions);
+const defaultHttpsAgent = new https__default["default"].Agent(agentOptions);
+function createHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions = {}, } = {}) {
     const httpAgent = userHttpAgent || userGlobalAgent || defaultHttpAgent;
     const httpsAgent = userHttpsAgent || userGlobalAgent || defaultHttpsAgent;
-    return {
-        send(request) {
-            return new Promise(resolve => {
-                const url = URL.parse(request.url);
-                const path = url.query === null ? url.pathname : `${url.pathname}?${url.query}`;
-                const options = {
-                    ...requesterOptions,
-                    agent: url.protocol === 'https:' ? httpsAgent : httpAgent,
-                    hostname: url.hostname,
-                    path,
-                    method: request.method,
-                    headers: {
-                        ...(requesterOptions && requesterOptions.headers ? requesterOptions.headers : {}),
-                        ...request.headers,
-                    },
-                    ...(url.port !== undefined ? { port: url.port || '' } : {}),
-                };
-                const req = (url.protocol === 'https:' ? https : http).request(options, response => {
-                    // eslint-disable-next-line functional/no-let
-                    let contentBuffers = [];
-                    response.on('data', chunk => {
-                        contentBuffers = contentBuffers.concat(chunk);
-                    });
-                    response.on('end', () => {
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        clearTimeout(connectTimeout);
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        clearTimeout(responseTimeout);
-                        resolve({
-                            status: response.statusCode || 0,
-                            content: Buffer.concat(contentBuffers).toString(),
-                            isTimedOut: false,
-                        });
-                    });
+    function send(request) {
+        return new Promise((resolve) => {
+            let responseTimeout;
+            // eslint-disable-next-line prefer-const -- linter thinks this is not reassigned
+            let connectTimeout;
+            const url$1 = new url.URL(request.url);
+            const path = url$1.search === null ? url$1.pathname : `${url$1.pathname}${url$1.search}`;
+            const options = {
+                agent: url$1.protocol === 'https:' ? httpsAgent : httpAgent,
+                hostname: url$1.hostname,
+                path,
+                method: request.method,
+                ...requesterOptions,
+                headers: {
+                    ...request.headers,
+                    ...requesterOptions.headers,
+                },
+            };
+            if (url$1.port && !requesterOptions.port) {
+                options.port = url$1.port;
+            }
+            const req = (url$1.protocol === 'https:' ? https__default["default"] : http__default["default"]).request(options, (response) => {
+                let contentBuffers = [];
+                response.on('data', (chunk) => {
+                    contentBuffers = contentBuffers.concat(chunk);
                 });
-                const createTimeout = (timeout, content) => {
-                    return setTimeout(() => {
-                        req.abort();
-                        resolve({
-                            status: 0,
-                            content,
-                            isTimedOut: true,
-                        });
-                    }, timeout * 1000);
-                };
-                const connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
-                // eslint-disable-next-line functional/no-let
-                let responseTimeout;
-                req.on('error', error => {
+                response.on('end', () => {
                     clearTimeout(connectTimeout);
                     clearTimeout(responseTimeout);
-                    resolve({ status: 0, content: error.message, isTimedOut: false });
-                });
-                req.once('response', () => {
-                    clearTimeout(connectTimeout);
-                    responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
+                    resolve({
+                        status: response.statusCode || 0,
+                        content: Buffer.concat(contentBuffers).toString(),
+                        isTimedOut: false,
+                    });
                 });
-                if (request.data !== undefined) {
-                    req.write(request.data);
-                }
-                req.end();
             });
-        },
-        destroy() {
-            httpAgent.destroy();
-            httpsAgent.destroy();
-            return Promise.resolve();
-        },
-    };
+            const createTimeout = (timeout, content) => {
+                return setTimeout(() => {
+                    req.destroy();
+                    resolve({
+                        status: 0,
+                        content,
+                        isTimedOut: true,
+                    });
+                }, timeout);
+            };
+            connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
+            req.on('error', (error) => {
+                clearTimeout(connectTimeout);
+                clearTimeout(responseTimeout);
+                resolve({ status: 0, content: error.message, isTimedOut: false });
+            });
+            req.once('response', () => {
+                clearTimeout(connectTimeout);
+                responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
+            });
+            if (request.data !== undefined) {
+                req.write(request.data);
+            }
+            req.end();
+        });
+    }
+    return { send };
 }
 
-exports.createNodeHttpRequester = createNodeHttpRequester;
+exports.createHttpRequester = createHttpRequester;
+exports.echoRequester = echoRequester;

package/dist/requester-node-http.esm.node.js

@@ -0,0 +1,82 @@
+import { URL } from 'url';
+import { createEchoRequester } from '@algolia/client-common';
+import http from 'http';
+import https from 'https';
+
+function echoRequester(status = 200) {
+    return createEchoRequester({ getURL: (url) => new URL(url), status });
+}
+
+// Global agents allow us to reuse the TCP protocol with multiple clients
+const agentOptions = { keepAlive: true };
+const defaultHttpAgent = new http.Agent(agentOptions);
+const defaultHttpsAgent = new https.Agent(agentOptions);
+function createHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions = {}, } = {}) {
+    const httpAgent = userHttpAgent || userGlobalAgent || defaultHttpAgent;
+    const httpsAgent = userHttpsAgent || userGlobalAgent || defaultHttpsAgent;
+    function send(request) {
+        return new Promise((resolve) => {
+            let responseTimeout;
+            // eslint-disable-next-line prefer-const -- linter thinks this is not reassigned
+            let connectTimeout;
+            const url = new URL(request.url);
+            const path = url.search === null ? url.pathname : `${url.pathname}${url.search}`;
+            const options = {
+                agent: url.protocol === 'https:' ? httpsAgent : httpAgent,
+                hostname: url.hostname,
+                path,
+                method: request.method,
+                ...requesterOptions,
+                headers: {
+                    ...request.headers,
+                    ...requesterOptions.headers,
+                },
+            };
+            if (url.port && !requesterOptions.port) {
+                options.port = url.port;
+            }
+            const req = (url.protocol === 'https:' ? https : http).request(options, (response) => {
+                let contentBuffers = [];
+                response.on('data', (chunk) => {
+                    contentBuffers = contentBuffers.concat(chunk);
+                });
+                response.on('end', () => {
+                    clearTimeout(connectTimeout);
+                    clearTimeout(responseTimeout);
+                    resolve({
+                        status: response.statusCode || 0,
+                        content: Buffer.concat(contentBuffers).toString(),
+                        isTimedOut: false,
+                    });
+                });
+            });
+            const createTimeout = (timeout, content) => {
+                return setTimeout(() => {
+                    req.destroy();
+                    resolve({
+                        status: 0,
+                        content,
+                        isTimedOut: true,
+                    });
+                }, timeout);
+            };
+            connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
+            req.on('error', (error) => {
+                clearTimeout(connectTimeout);
+                clearTimeout(responseTimeout);
+                resolve({ status: 0, content: error.message, isTimedOut: false });
+            });
+            req.once('response', () => {
+                clearTimeout(connectTimeout);
+                responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
+            });
+            if (request.data !== undefined) {
+                req.write(request.data);
+            }
+            req.end();
+        });
+    }
+    return { send };
+}
+
+export { createHttpRequester, echoRequester };

package/dist/src/createHttpRequester.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+import type { Requester } from '@algolia/client-common';
+export declare type CreateHttpRequesterOptions = Partial<{
+    agent: http.Agent | https.Agent;
+    httpAgent: http.Agent;
+    httpsAgent: https.Agent;
+    /**
+     * RequestOptions to be merged with the end request, it will override default options if provided.
+     */
+    requesterOptions: https.RequestOptions;
+}>;
+export declare function createHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions, }?: CreateHttpRequesterOptions): Requester;
+//# sourceMappingURL=createHttpRequester.d.ts.map

package/dist/src/createHttpRequester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHttpRequester.d.ts","sourceRoot":"","sources":["../../../../packages/requester-node-http/src/createHttpRequester.ts"],"names":[],"mappings":";;AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,KAAK,EAAc,SAAS,EAAY,MAAM,wBAAwB,CAAC;AAE9E,oBAAY,0BAA0B,GAAG,OAAO,CAAC;IAC/C,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAChC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC;IACtB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB;;OAEG;IACH,gBAAgB,EAAE,KAAK,CAAC,cAAc,CAAC;CACxC,CAAC,CAAC;AAOH,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,cAAc,EAC1B,gBAAqB,GACtB,GAAE,0BAA+B,GAAG,SAAS,CA6F7C"}

package/dist/src/echoRequester.d.ts

@@ -0,0 +1,3 @@
+import type { Requester } from '@algolia/client-common';
+export declare function echoRequester(status?: number): Requester;
+//# sourceMappingURL=echoRequester.d.ts.map

package/dist/src/echoRequester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echoRequester.d.ts","sourceRoot":"","sources":["../../../../packages/requester-node-http/src/echoRequester.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,wBAAgB,aAAa,CAAC,MAAM,GAAE,MAAY,GAAG,SAAS,CAE7D"}

package/index.ts

@@ -0,0 +1,2 @@
+export * from './src/echoRequester';
+export * from './src/createHttpRequester';

package/package.json

@@ -1,22 +1,34 @@
 {
   "name": "@algolia/requester-node-http",
-  "version": "4.14.2",
-  "private": false,
+  "version": "5.0.0-alpha.3",
   "description": "Promise-based request library for node using the native http module.",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/algolia/algoliasearch-client-javascript.git"
-  },
+  "repository": "algolia/algoliasearch-client-javascript",
   "license": "MIT",
-  "sideEffects": false,
-  "main": "index.js",
-  "module": "dist/requester-node-http.esm.js",
-  "types": "dist/requester-node-http.d.ts",
+  "author": "Algolia",
+  "main": "dist/requester-node-http.cjs.js",
+  "module": "dist/requester-node-http.esm.node.js",
+  "types": "dist/index.d.ts",
   "files": [
-    "index.js",
-    "dist"
+    "dist",
+    "src",
+    "index.ts"
   ],
+  "scripts": {
+    "clean": "rm -rf dist/",
+    "test": "jest"
+  },
   "dependencies": {
-    "@algolia/requester-common": "4.14.2"
+    "@algolia/client-common": "5.0.0-alpha.3"
+  },
+  "devDependencies": {
+    "@types/jest": "28.1.6",
+    "@types/node": "16.11.45",
+    "jest": "28.1.3",
+    "nock": "13.2.9",
+    "ts-jest": "28.0.5",
+    "typescript": "4.7.4"
+  },
+  "engines": {
+    "node": ">= 14.0.0"
   }
 }

package/src/__tests__/node-http-requester.test.ts

@@ -0,0 +1,293 @@
+import http from 'http';
+import https from 'https';
+import { Readable } from 'stream';
+
+import type { EndRequest } from '@algolia/client-common';
+import nock from 'nock';
+
+import { createHttpRequester } from '../..';
+import {
+  headers,
+  timeoutRequest,
+  requestStub,
+  testQueryHeader,
+  testQueryBaseUrl,
+  getStringifiedBody,
+  createTestServer,
+} from '../../../../tests/utils';
+
+const requester = createHttpRequester();
+
+const httpsBaseRequest = https.request;
+const httpBaseRequest = http.request;
+
+describe('api', () => {
+  const mockedRequestResponse = {
+    destroy: jest.fn(),
+    on: jest.fn(),
+    once: jest.fn(),
+    write: jest.fn(),
+    end: jest.fn(),
+  };
+
+  beforeAll(() => {
+    // @ts-expect-error we don't care about the response for those tests
+    https.request = jest.fn(() => mockedRequestResponse);
+  });
+
+  afterAll(() => {
+    https.request = httpsBaseRequest;
+    http.request = httpBaseRequest;
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+  });
+
+  it('allow init without parameters', () => {
+    expect(() => createHttpRequester()).not.toThrow();
+  });
+
+  it('allow providing custom agent', async () => {
+    const agent = new http.Agent();
+    // @ts-expect-error we don't care about the response for those tests
+    http.request = jest.fn(() => mockedRequestResponse);
+    const tmpRequester = createHttpRequester({
+      agent,
+    });
+
+    await tmpRequester.send({
+      ...requestStub,
+      url: 'http://algolia-dns.net/foo?x-algolia-header=bar',
+    });
+
+    expect(http.request).toHaveBeenCalled();
+  });
+
+  it('allow overriding default options', async () => {
+    const tmpRequester = createHttpRequester({
+      requesterOptions: {
+        headers: {
+          'my-extra-header': 'algolia',
+        },
+      },
+    });
+
+    await tmpRequester.send(requestStub);
+
+    expect(https.request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'my-extra-header': 'algolia',
+        }),
+      }),
+      expect.any(Function)
+    );
+  });
+});
+
+describe('status code handling', () => {
+  it('sends requests', async () => {
+    const body = getStringifiedBody();
+
+    nock(testQueryBaseUrl, { reqheaders: headers })
+      .post('/foo')
+      .query(testQueryHeader)
+      .reply(200, body);
+
+    const response = await requester.send(requestStub);
+
+    expect(response.content).toEqual(body);
+  });
+
+  it('resolves status 200', async () => {
+    const body = getStringifiedBody();
+
+    nock(testQueryBaseUrl, { reqheaders: headers })
+      .post('/foo')
+      .query(testQueryHeader)
+      .reply(200, body);
+
+    const response = await requester.send(requestStub);
+
+    expect(response.status).toBe(200);
+    expect(response.content).toBe(body);
+    expect(response.isTimedOut).toBe(false);
+  });
+
+  it('resolves status 300', async () => {
+    const reason = 'Multiple Choices';
+
+    nock(testQueryBaseUrl, { reqheaders: headers })
+      .post('/foo')
+      .query(testQueryHeader)
+      .reply(300, reason);
+
+    const response = await requester.send(requestStub);
+
+    expect(response.status).toBe(300);
+    expect(response.content).toBe(reason);
+    expect(response.isTimedOut).toBe(false);
+  });
+
+  it('resolves status 400', async () => {
+    const body = getStringifiedBody({
+      message: 'Invalid Application-Id or API-Key',
+    });
+
+    nock(testQueryBaseUrl, { reqheaders: headers })
+      .post('/foo')
+      .query(testQueryHeader)
+      .reply(400, body);
+
+    const response = await requester.send(requestStub);
+
+    expect(response.status).toBe(400);
+    expect(response.content).toBe(body);
+    expect(response.isTimedOut).toBe(false);
+  });
+
+  it('handles chunked responses inside unicode character boundaries', async () => {
+    const data = Buffer.from('äöü');
+
+    // create a test response stream that is chunked inside a unicode character
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    function* generate() {
+      yield data.slice(0, 3);
+      yield data.slice(3);
+    }
+
+    const testStream = Readable.from(generate());
+
+    nock(testQueryBaseUrl, { reqheaders: headers })
+      .post('/foo')
+      .query(testQueryHeader)
+      .reply(200, testStream);
+
+    const response = await requester.send(requestStub);
+
+    expect(response.content).toEqual(data.toString());
+  });
+});
+
+describe('timeout handling', () => {
+  let server: http.Server;
+  // setup http server to test timeout
+  beforeAll(() => {
+    server = createTestServer();
+
+    server.listen('1111');
+  });
+
+  afterAll((done) => {
+    server.close(() => done());
+  });
+
+  it('timeouts with the given 1 seconds connection timeout', async () => {
+    const before = Date.now();
+    const response = await requester.send({
+      ...timeoutRequest,
+      connectTimeout: 1000,
+      url: 'http://www.google.com:81',
+    });
+
+    const now = Date.now();
+
+    expect(response.content).toBe('Connection timeout');
+    expect(now - before).toBeGreaterThan(999);
+    expect(now - before).toBeLessThan(1200);
+  });
+
+  it('connection timeouts with the given 2 seconds connection timeout', async () => {
+    const before = Date.now();
+    const response = await requester.send({
+      ...timeoutRequest,
+      connectTimeout: 2000,
+      url: 'http://www.google.com:81',
+    });
+
+    const now = Date.now();
+
+    expect(response.content).toBe('Connection timeout');
+    expect(now - before).toBeGreaterThan(1999);
+    expect(now - before).toBeLessThan(2200);
+  });
+
+  it("socket timeouts if response don't appears before the timeout with 2 seconds timeout", async () => {
+    const before = Date.now();
+
+    const response = await requester.send({
+      ...timeoutRequest,
+      responseTimeout: 2000,
+      url: 'http://localhost:1111',
+    });
+
+    const now = Date.now();
+
+    expect(response.content).toBe('Socket timeout');
+    expect(now - before).toBeGreaterThan(1999);
+    expect(now - before).toBeLessThan(2200);
+  });
+
+  it("socket timeouts if response don't appears before the timeout with 3 seconds timeout", async () => {
+    const before = Date.now();
+    const response = await requester.send({
+      ...timeoutRequest,
+      responseTimeout: 3000,
+      url: 'http://localhost:1111',
+    });
+
+    const now = Date.now();
+
+    expect(response.content).toBe('Socket timeout');
+    expect(now - before).toBeGreaterThan(2999);
+    expect(now - before).toBeLessThan(3200);
+  });
+
+  it('do not timeouts if response appears before the timeout', async () => {
+    const before = Date.now();
+    const response = await requester.send({
+      ...requestStub,
+      url: 'http://localhost:1111',
+      responseTimeout: 6000,
+    });
+
+    const now = Date.now();
+
+    expect(response.isTimedOut).toBe(false);
+    expect(response.status).toBe(200);
+    expect(response.content).toBe('{"foo": "bar"}');
+    expect(now - before).toBeGreaterThan(4999);
+    expect(now - before).toBeLessThan(5200);
+  }, 10000); // This is a long-running test, default server timeout is set to 5000ms
+});
+
+describe('error handling', (): void => {
+  it('resolves dns not found', async () => {
+    const request: EndRequest = {
+      url: 'https://this-dont-exist.algolia.com',
+      method: 'POST',
+      headers,
+      data: getStringifiedBody(),
+      responseTimeout: 2000,
+      connectTimeout: 1000,
+    };
+
+    const response = await requester.send(request);
+
+    expect(response.status).toBe(0);
+    expect(response.content).toContain('');
+    expect(response.isTimedOut).toBe(false);
+  });
+
+  it('resolves general network errors', async () => {
+    nock(testQueryBaseUrl, { reqheaders: headers })
+      .post('/foo')
+      .query(testQueryHeader)
+      .replyWithError('This is a general error');
+
+    const response = await requester.send(requestStub);
+
+    expect(response.status).toBe(0);
+    expect(response.content).toBe('This is a general error');
+    expect(response.isTimedOut).toBe(false);
+  });
+});

package/src/createHttpRequester.ts

@@ -0,0 +1,120 @@
+import http from 'http';
+import https from 'https';
+import { URL } from 'url';
+
+import type { EndRequest, Requester, Response } from '@algolia/client-common';
+
+export type CreateHttpRequesterOptions = Partial<{
+  agent: http.Agent | https.Agent;
+  httpAgent: http.Agent;
+  httpsAgent: https.Agent;
+  /**
+   * RequestOptions to be merged with the end request, it will override default options if provided.
+   */
+  requesterOptions: https.RequestOptions;
+}>;
+
+// Global agents allow us to reuse the TCP protocol with multiple clients
+const agentOptions = { keepAlive: true };
+const defaultHttpAgent = new http.Agent(agentOptions);
+const defaultHttpsAgent = new https.Agent(agentOptions);
+
+export function createHttpRequester({
+  agent: userGlobalAgent,
+  httpAgent: userHttpAgent,
+  httpsAgent: userHttpsAgent,
+  requesterOptions = {},
+}: CreateHttpRequesterOptions = {}): Requester {
+  const httpAgent = userHttpAgent || userGlobalAgent || defaultHttpAgent;
+  const httpsAgent = userHttpsAgent || userGlobalAgent || defaultHttpsAgent;
+
+  function send(request: EndRequest): Promise<Response> {
+    return new Promise((resolve) => {
+      let responseTimeout: NodeJS.Timeout | undefined;
+      // eslint-disable-next-line prefer-const -- linter thinks this is not reassigned
+      let connectTimeout: NodeJS.Timeout | undefined;
+      const url = new URL(request.url);
+      const path =
+        url.search === null ? url.pathname : `${url.pathname}${url.search}`;
+      const options: https.RequestOptions = {
+        agent: url.protocol === 'https:' ? httpsAgent : httpAgent,
+        hostname: url.hostname,
+        path,
+        method: request.method,
+        ...requesterOptions,
+        headers: {
+          ...request.headers,
+          ...requesterOptions.headers,
+        },
+      };
+
+      if (url.port && !requesterOptions.port) {
+        options.port = url.port;
+      }
+
+      const req = (url.protocol === 'https:' ? https : http).request(
+        options,
+        (response) => {
+          let contentBuffers: Buffer[] = [];
+
+          response.on('data', (chunk) => {
+            contentBuffers = contentBuffers.concat(chunk);
+          });
+
+          response.on('end', () => {
+            clearTimeout(connectTimeout as NodeJS.Timeout);
+            clearTimeout(responseTimeout as NodeJS.Timeout);
+
+            resolve({
+              status: response.statusCode || 0,
+              content: Buffer.concat(contentBuffers).toString(),
+              isTimedOut: false,
+            });
+          });
+        }
+      );
+
+      const createTimeout = (
+        timeout: number,
+        content: string
+      ): NodeJS.Timeout => {
+        return setTimeout(() => {
+          req.destroy();
+
+          resolve({
+            status: 0,
+            content,
+            isTimedOut: true,
+          });
+        }, timeout);
+      };
+
+      connectTimeout = createTimeout(
+        request.connectTimeout,
+        'Connection timeout'
+      );
+
+      req.on('error', (error) => {
+        clearTimeout(connectTimeout as NodeJS.Timeout);
+        clearTimeout(responseTimeout!);
+        resolve({ status: 0, content: error.message, isTimedOut: false });
+      });
+
+      req.once('response', () => {
+        clearTimeout(connectTimeout as NodeJS.Timeout);
+        responseTimeout = createTimeout(
+          request.responseTimeout,
+          'Socket timeout'
+        );
+      });
+
+      if (request.data !== undefined) {
+        req.write(request.data);
+      }
+
+      req.end();
+    });
+  }
+
+  return { send };
+}

package/src/echoRequester.ts

@@ -0,0 +1,8 @@
+import { URL } from 'url';
+
+import { createEchoRequester } from '@algolia/client-common';
+import type { Requester } from '@algolia/client-common';
+
+export function echoRequester(status: number = 200): Requester {
+  return createEchoRequester({ getURL: (url: string) => new URL(url), status });
+}

package/dist/requester-node-http.d.ts

@@ -1,16 +0,0 @@
-/// <reference types="node" />
-import { Destroyable } from '@algolia/requester-common';
-import * as http from 'http';
-import * as https from 'https';
-import { Requester } from '@algolia/requester-common';
-
-export declare function createNodeHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions, }?: NodeHttpRequesterOptions): Requester & Destroyable;
-
-export declare type NodeHttpRequesterOptions = {
-    agent?: https.Agent | http.Agent;
-    httpAgent?: http.Agent;
-    httpsAgent?: https.Agent;
-    requesterOptions?: https.RequestOptions;
-};
-
-export { }

package/dist/requester-node-http.esm.js

@@ -1,85 +0,0 @@
-import * as http from 'http';
-import { Agent } from 'http';
-import * as https from 'https';
-import { Agent as Agent$1 } from 'https';
-import { parse } from 'url';
-
-/* eslint functional/prefer-readonly-type: 0 */
-const agentOptions = { keepAlive: true };
-const defaultHttpAgent = new Agent(agentOptions);
-const defaultHttpsAgent = new Agent$1(agentOptions);
-function createNodeHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions = {}, } = {}) {
-    const httpAgent = userHttpAgent || userGlobalAgent || defaultHttpAgent;
-    const httpsAgent = userHttpsAgent || userGlobalAgent || defaultHttpsAgent;
-    return {
-        send(request) {
-            return new Promise(resolve => {
-                const url = parse(request.url);
-                const path = url.query === null ? url.pathname : `${url.pathname}?${url.query}`;
-                const options = {
-                    ...requesterOptions,
-                    agent: url.protocol === 'https:' ? httpsAgent : httpAgent,
-                    hostname: url.hostname,
-                    path,
-                    method: request.method,
-                    headers: {
-                        ...(requesterOptions && requesterOptions.headers ? requesterOptions.headers : {}),
-                        ...request.headers,
-                    },
-                    ...(url.port !== undefined ? { port: url.port || '' } : {}),
-                };
-                const req = (url.protocol === 'https:' ? https : http).request(options, response => {
-                    // eslint-disable-next-line functional/no-let
-                    let contentBuffers = [];
-                    response.on('data', chunk => {
-                        contentBuffers = contentBuffers.concat(chunk);
-                    });
-                    response.on('end', () => {
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        clearTimeout(connectTimeout);
-                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                        clearTimeout(responseTimeout);
-                        resolve({
-                            status: response.statusCode || 0,
-                            content: Buffer.concat(contentBuffers).toString(),
-                            isTimedOut: false,
-                        });
-                    });
-                });
-                const createTimeout = (timeout, content) => {
-                    return setTimeout(() => {
-                        req.abort();
-                        resolve({
-                            status: 0,
-                            content,
-                            isTimedOut: true,
-                        });
-                    }, timeout * 1000);
-                };
-                const connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
-                // eslint-disable-next-line functional/no-let
-                let responseTimeout;
-                req.on('error', error => {
-                    clearTimeout(connectTimeout);
-                    clearTimeout(responseTimeout);
-                    resolve({ status: 0, content: error.message, isTimedOut: false });
-                });
-                req.once('response', () => {
-                    clearTimeout(connectTimeout);
-                    responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
-                });
-                if (request.data !== undefined) {
-                    req.write(request.data);
-                }
-                req.end();
-            });
-        },
-        destroy() {
-            httpAgent.destroy();
-            httpsAgent.destroy();
-            return Promise.resolve();
-        },
-    };
-}
-
-export { createNodeHttpRequester };

package/index.js

@@ -1,2 +0,0 @@
-// eslint-disable-next-line functional/immutable-data, import/no-commonjs
-module.exports = require('./dist/requester-node-http.cjs.js');