@algolia/requester-node-http 5.0.0-alpha.1 → 5.0.0-alpha.100

package/dist/index.d.ts

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

package/dist/{requester-node-http.cjs.js → requester-node-http.cjs}

@@ -1,83 +1,84 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var url = require('url');
 var clientCommon = require('@algolia/client-common');
 var http = require('http');
 var https = require('https');
 
-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 });
+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 httpAgent = new http__default["default"].Agent(agentOptions);
-const httpsAgent = new https__default["default"].Agent(agentOptions);
-function createHttpRequester() {
-    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,
-                headers: request.headers,
-                ...(url$1.port !== undefined ? { 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);
-                });
-                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 };
+// 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$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 : 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 };
 }
 
 exports.createHttpRequester = createHttpRequester;

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

@@ -3,72 +3,80 @@ 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 });
+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 httpAgent = new http.Agent(agentOptions);
-const httpsAgent = new https.Agent(agentOptions);
-function createHttpRequester() {
-    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,
-                headers: request.headers,
-                ...(url.port !== undefined ? { 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 };
+// 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

@@ -1,3 +1,16 @@
-import type { Requester } from '@algolia/client-common';
-export declare function createHttpRequester(): Requester;
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+import type { Requester } 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;
+}>;
+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

@@ -1 +1 @@
-{"version":3,"file":"createHttpRequester.d.ts","sourceRoot":"","sources":["../../../../packages/requester-node-http/src/createHttpRequester.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAc,SAAS,EAAY,MAAM,wBAAwB,CAAC;AAO9E,wBAAgB,mBAAmB,IAAI,SAAS,CAmF/C"}
+{"version":3,"file":"createHttpRequester.d.ts","sourceRoot":"","sources":["../../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,MAAM,MAAM,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

@@ -1,3 +1,3 @@
-import type { Requester } from '@algolia/client-common';
-export declare function echoRequester(status?: number): Requester;
+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

@@ -1 +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"}
+{"version":3,"file":"echoRequester.d.ts","sourceRoot":"","sources":["../../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/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@algolia/requester-node-http",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.100",
   "description": "Promise-based request library for node using the native http module.",
   "repository": "algolia/algoliasearch-client-javascript",
   "license": "MIT",
   "author": "Algolia",
-  "main": "dist/requester-node-http.cjs.js",
+  "type": "module",
+  "main": "dist/requester-node-http.cjs",
   "module": "dist/requester-node-http.esm.node.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -14,19 +15,22 @@
     "index.ts"
   ],
   "scripts": {
-    "clean": "rm -rf dist/",
+    "build": "yarn clean && rollup --config",
+    "clean": "rm -rf ./dist || true",
     "test": "jest"
   },
   "dependencies": {
-    "@algolia/client-common": "5.0.0-alpha.1"
+    "@algolia/client-common": "5.0.0-alpha.100"
   },
   "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"
+    "@babel/preset-env": "7.23.9",
+    "@babel/preset-typescript": "7.23.3",
+    "@types/jest": "29.5.11",
+    "@types/node": "20.11.0",
+    "jest": "29.7.0",
+    "nock": "13.5.1",
+    "ts-jest": "29.1.2",
+    "typescript": "5.3.3"
   },
   "engines": {
     "node": ">= 14.0.0"

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

@@ -1,4 +1,5 @@
-import type http from 'http';
+import http from 'http';
+import https from 'https';
 import { Readable } from 'stream';
 
 import type { EndRequest } from '@algolia/client-common';
@@ -17,6 +18,72 @@ import {
 
 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();
@@ -84,8 +151,8 @@ describe('status code handling', () => {
     // 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);
+      yield data.subarray(0, 3);
+      yield data.subarray(3);
     }
 
     const testStream = Readable.from(generate());
@@ -119,14 +186,14 @@ describe('timeout handling', () => {
     const response = await requester.send({
       ...timeoutRequest,
       connectTimeout: 1000,
-      url: 'http://www.google.com:81',
+      url: 'http://localhost:1111/connection_timeout',
     });
 
     const now = Date.now();
 
     expect(response.content).toBe('Connection timeout');
-    expect(now - before).toBeGreaterThan(999);
-    expect(now - before).toBeLessThan(1200);
+    expect(now - before).toBeGreaterThanOrEqual(999);
+    expect(now - before).toBeLessThanOrEqual(1200);
   });
 
   it('connection timeouts with the given 2 seconds connection timeout', async () => {
@@ -134,14 +201,14 @@ describe('timeout handling', () => {
     const response = await requester.send({
       ...timeoutRequest,
       connectTimeout: 2000,
-      url: 'http://www.google.com:81',
+      url: 'http://localhost:1111/connection_timeout',
     });
 
     const now = Date.now();
 
     expect(response.content).toBe('Connection timeout');
-    expect(now - before).toBeGreaterThan(1999);
-    expect(now - before).toBeLessThan(2200);
+    expect(now - before).toBeGreaterThanOrEqual(1999);
+    expect(now - before).toBeLessThanOrEqual(2200);
   });
 
   it("socket timeouts if response don't appears before the timeout with 2 seconds timeout", async () => {
@@ -156,8 +223,8 @@ describe('timeout handling', () => {
     const now = Date.now();
 
     expect(response.content).toBe('Socket timeout');
-    expect(now - before).toBeGreaterThan(1999);
-    expect(now - before).toBeLessThan(2200);
+    expect(now - before).toBeGreaterThanOrEqual(1999);
+    expect(now - before).toBeLessThanOrEqual(2200);
   });
 
   it("socket timeouts if response don't appears before the timeout with 3 seconds timeout", async () => {
@@ -171,8 +238,8 @@ describe('timeout handling', () => {
     const now = Date.now();
 
     expect(response.content).toBe('Socket timeout');
-    expect(now - before).toBeGreaterThan(2999);
-    expect(now - before).toBeLessThan(3200);
+    expect(now - before).toBeGreaterThanOrEqual(2999);
+    expect(now - before).toBeLessThanOrEqual(3200);
   });
 
   it('do not timeouts if response appears before the timeout', async () => {
@@ -188,8 +255,8 @@ describe('timeout handling', () => {
     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);
+    expect(now - before).toBeGreaterThanOrEqual(4999);
+    expect(now - before).toBeLessThanOrEqual(5200);
   }, 10000); // This is a long-running test, default server timeout is set to 5000ms
 });
 

package/src/createHttpRequester.ts

@@ -4,12 +4,30 @@ 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 httpAgent = new http.Agent(agentOptions);
-const httpsAgent = new https.Agent(agentOptions);
+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;
 
-export function createHttpRequester(): Requester {
   function send(request: EndRequest): Promise<Response> {
     return new Promise((resolve) => {
       let responseTimeout: NodeJS.Timeout | undefined;
@@ -23,10 +41,17 @@ export function createHttpRequester(): Requester {
         hostname: url.hostname,
         path,
         method: request.method,
-        headers: request.headers,
-        ...(url.port !== undefined ? { port: url.port || '' } : {}),
+        ...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) => {