@algolia/requester-node-http 5.8.1 → 5.9.1

package/dist/requester.http.d.cts

@@ -1,16 +1,81 @@
 import http from 'http';
 import https from 'https';
-import { Requester } from '@algolia/client-common';
+import { URL } from 'url';
 
-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;
-}>;
-declare function createHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions, }?: CreateHttpRequesterOptions): Requester;
+// src/createHttpRequester.ts
+var agentOptions = { keepAlive: true };
+var defaultHttpAgent = new http.Agent(agentOptions);
+var 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;
+      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 !== void 0) {
+        req.write(request.data);
+      }
+      req.end();
+    });
+  }
+  return { send };
+}
 
-export { type CreateHttpRequesterOptions, createHttpRequester };
+export { createHttpRequester };

package/dist/requester.http.d.ts

@@ -1,16 +1,81 @@
 import http from 'http';
 import https from 'https';
-import { Requester } from '@algolia/client-common';
+import { URL } from 'url';
 
-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;
-}>;
-declare function createHttpRequester({ agent: userGlobalAgent, httpAgent: userHttpAgent, httpsAgent: userHttpsAgent, requesterOptions, }?: CreateHttpRequesterOptions): Requester;
+// src/createHttpRequester.ts
+var agentOptions = { keepAlive: true };
+var defaultHttpAgent = new http.Agent(agentOptions);
+var 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;
+      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 !== void 0) {
+        req.write(request.data);
+      }
+      req.end();
+    });
+  }
+  return { send };
+}
 
-export { type CreateHttpRequesterOptions, createHttpRequester };
+export { createHttpRequester };

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist/requester.http';

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./dist/requester.http.cjs');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/requester-node-http",
-  "version": "5.8.1",
+  "version": "5.9.1",
   "description": "Promise-based request library for node using the native http module.",
   "repository": {
     "type": "git",
@@ -11,8 +11,8 @@
   "type": "module",
   "files": [
     "dist",
-    "src",
-    "index.ts"
+    "index.d.ts",
+    "index.js"
   ],
   "exports": {
     ".": {
@@ -34,15 +34,15 @@
     "test:bundle": "publint . && attw --pack ."
   },
   "dependencies": {
-    "@algolia/client-common": "5.8.1"
+    "@algolia/client-common": "5.9.1"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.16.4",
-    "@types/node": "22.7.4",
+    "@types/node": "22.7.5",
     "nock": "13.5.5",
     "publint": "0.2.11",
     "tsup": "8.3.0",
-    "typescript": "5.6.2",
+    "typescript": "5.6.3",
     "vitest": "2.1.2"
   },
   "engines": {

package/index.ts

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

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

@@ -1,281 +0,0 @@
-import http from 'http';
-import https from 'https';
-import nock from 'nock';
-import { Readable } from 'stream';
-import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
-
-import type { EndRequest } from '@algolia/client-common';
-
-import { createHttpRequester } from '../..';
-import {
-  createTestServer,
-  getStringifiedBody,
-  headers,
-  requestStub,
-  testQueryBaseUrl,
-  testQueryHeader,
-  timeoutRequest,
-} from '../../../../tests/utils';
-
-const requester = createHttpRequester();
-
-const httpsBaseRequest = https.request;
-const httpBaseRequest = http.request;
-
-describe('api', () => {
-  const mockedRequestResponse = {
-    destroy: vi.fn(),
-    on: vi.fn(),
-    once: vi.fn(),
-    write: vi.fn(),
-    end: vi.fn(),
-  };
-
-  beforeAll(() => {
-    // @ts-expect-error we don't care about the response for those tests
-    https.request = vi.fn(() => mockedRequestResponse);
-  });
-
-  afterAll(() => {
-    https.request = httpsBaseRequest;
-    http.request = httpBaseRequest;
-    vi.resetAllMocks();
-    vi.clearAllMocks();
-  });
-
-  test('allow init without parameters', () => {
-    expect(() => createHttpRequester()).not.toThrow();
-  });
-
-  test('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 = vi.fn(() => mockedRequestResponse);
-    const tmpRequester = createHttpRequester({
-      agent,
-    });
-
-    await tmpRequester.send({
-      ...requestStub,
-      url: 'http://algolia-dns.net/foo?x-algolia-header=bar',
-    });
-
-    expect(http.request).toHaveBeenCalled();
-  });
-
-  test('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', () => {
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('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);
-  });
-
-  test('handles chunked responses inside unicode character boundaries', async () => {
-    const data = Buffer.from('äöü');
-
-    // create a test response stream that is chunked inside a unicode character
-    function* generate() {
-      yield data.subarray(0, 3);
-      yield data.subarray(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('1112');
-  });
-
-  afterAll(
-    () =>
-      new Promise((done) => {
-        done();
-      }),
-  );
-
-  test('timeouts with the given 1 seconds connection timeout', async () => {
-    const before = Date.now();
-    const response = await requester.send({
-      ...timeoutRequest,
-      connectTimeout: 1000,
-      url: 'http://localhost:1112/connection_timeout',
-    });
-
-    const now = Date.now();
-
-    expect(response.content).toBe('Connection timeout');
-    expect(now - before).toBeGreaterThanOrEqual(999);
-    expect(now - before).toBeLessThanOrEqual(1200);
-  });
-
-  test('connection timeouts with the given 2 seconds connection timeout', async () => {
-    const before = Date.now();
-    const response = await requester.send({
-      ...timeoutRequest,
-      connectTimeout: 2000,
-      url: 'http://localhost:1112/connection_timeout',
-    });
-
-    const now = Date.now();
-
-    expect(response.content).toBe('Connection timeout');
-    expect(now - before).toBeGreaterThanOrEqual(1999);
-    expect(now - before).toBeLessThanOrEqual(2200);
-  });
-
-  test("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:1112',
-    });
-
-    const now = Date.now();
-
-    expect(response.content).toBe('Socket timeout');
-    expect(now - before).toBeGreaterThanOrEqual(1999);
-    expect(now - before).toBeLessThanOrEqual(2200);
-  });
-
-  test("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:1112',
-    });
-
-    const now = Date.now();
-
-    expect(response.content).toBe('Socket timeout');
-    expect(now - before).toBeGreaterThanOrEqual(2999);
-    expect(now - before).toBeLessThanOrEqual(3200);
-  });
-
-  test('do not timeouts if response appears before the timeout', async () => {
-    const before = Date.now();
-    const response = await requester.send({
-      ...requestStub,
-      url: 'http://localhost:1112',
-      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).toBeGreaterThanOrEqual(4999);
-    expect(now - before).toBeLessThanOrEqual(5200);
-  }, 10000); // This is a long-running test, default server timeout is set to 5000ms
-});
-
-describe('error handling', (): void => {
-  test('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);
-  });
-
-  test('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

@@ -1,106 +0,0 @@
-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;
-      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 };
-}