@algolia/requester-browser-xhr 4.14.2 → 5.0.0-alpha.3

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/createXhrRequester';
+export * from './src/echoRequester';
+//# 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,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

package/dist/requester-browser-xhr.cjs.js

@@ -2,60 +2,63 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function createBrowserXhrRequester() {
-    return {
-        send(request) {
-            return new Promise((resolve) => {
-                const baseRequester = new XMLHttpRequest();
-                baseRequester.open(request.method, request.url, true);
-                Object.keys(request.headers).forEach(key => baseRequester.setRequestHeader(key, request.headers[key]));
-                const createTimeout = (timeout, content) => {
-                    return setTimeout(() => {
-                        baseRequester.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;
-                // eslint-disable-next-line functional/immutable-data
-                baseRequester.onreadystatechange = () => {
-                    if (baseRequester.readyState > baseRequester.OPENED && responseTimeout === undefined) {
-                        clearTimeout(connectTimeout);
-                        responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
-                    }
-                };
-                // eslint-disable-next-line functional/immutable-data
-                baseRequester.onerror = () => {
-                    // istanbul ignore next
-                    if (baseRequester.status === 0) {
-                        clearTimeout(connectTimeout);
-                        clearTimeout(responseTimeout);
-                        resolve({
-                            content: baseRequester.responseText || 'Network request failed',
-                            status: baseRequester.status,
-                            isTimedOut: false,
-                        });
-                    }
-                };
-                //  eslint-disable-next-line functional/immutable-data
-                baseRequester.onload = () => {
+var clientCommon = require('@algolia/client-common');
+
+function createXhrRequester() {
+    function send(request) {
+        return new Promise((resolve) => {
+            const baseRequester = new XMLHttpRequest();
+            baseRequester.open(request.method, request.url, true);
+            Object.keys(request.headers).forEach((key) => baseRequester.setRequestHeader(key, request.headers[key]));
+            const createTimeout = (timeout, content) => {
+                return setTimeout(() => {
+                    baseRequester.abort();
+                    resolve({
+                        status: 0,
+                        content,
+                        isTimedOut: true,
+                    });
+                }, timeout);
+            };
+            const connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
+            let responseTimeout;
+            baseRequester.onreadystatechange = () => {
+                if (baseRequester.readyState > baseRequester.OPENED &&
+                    responseTimeout === undefined) {
+                    clearTimeout(connectTimeout);
+                    responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
+                }
+            };
+            baseRequester.onerror = () => {
+                // istanbul ignore next
+                if (baseRequester.status === 0) {
                     clearTimeout(connectTimeout);
                     clearTimeout(responseTimeout);
                     resolve({
-                        content: baseRequester.responseText,
+                        content: baseRequester.responseText || 'Network request failed',
                         status: baseRequester.status,
                         isTimedOut: false,
                     });
-                };
-                baseRequester.send(request.data);
-            });
-        },
-    };
+                }
+            };
+            baseRequester.onload = () => {
+                clearTimeout(connectTimeout);
+                clearTimeout(responseTimeout);
+                resolve({
+                    content: baseRequester.responseText,
+                    status: baseRequester.status,
+                    isTimedOut: false,
+                });
+            };
+            baseRequester.send(request.data);
+        });
+    }
+    return { send };
+}
+
+function echoRequester(status = 200) {
+    return clientCommon.createEchoRequester({ getURL: (url) => new URL(url), status });
 }
 
-exports.createBrowserXhrRequester = createBrowserXhrRequester;
+exports.createXhrRequester = createXhrRequester;
+exports.echoRequester = echoRequester;

package/dist/requester-browser-xhr.esm.node.js

@@ -0,0 +1,59 @@
+import { createEchoRequester } from '@algolia/client-common';
+
+function createXhrRequester() {
+    function send(request) {
+        return new Promise((resolve) => {
+            const baseRequester = new XMLHttpRequest();
+            baseRequester.open(request.method, request.url, true);
+            Object.keys(request.headers).forEach((key) => baseRequester.setRequestHeader(key, request.headers[key]));
+            const createTimeout = (timeout, content) => {
+                return setTimeout(() => {
+                    baseRequester.abort();
+                    resolve({
+                        status: 0,
+                        content,
+                        isTimedOut: true,
+                    });
+                }, timeout);
+            };
+            const connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
+            let responseTimeout;
+            baseRequester.onreadystatechange = () => {
+                if (baseRequester.readyState > baseRequester.OPENED &&
+                    responseTimeout === undefined) {
+                    clearTimeout(connectTimeout);
+                    responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
+                }
+            };
+            baseRequester.onerror = () => {
+                // istanbul ignore next
+                if (baseRequester.status === 0) {
+                    clearTimeout(connectTimeout);
+                    clearTimeout(responseTimeout);
+                    resolve({
+                        content: baseRequester.responseText || 'Network request failed',
+                        status: baseRequester.status,
+                        isTimedOut: false,
+                    });
+                }
+            };
+            baseRequester.onload = () => {
+                clearTimeout(connectTimeout);
+                clearTimeout(responseTimeout);
+                resolve({
+                    content: baseRequester.responseText,
+                    status: baseRequester.status,
+                    isTimedOut: false,
+                });
+            };
+            baseRequester.send(request.data);
+        });
+    }
+    return { send };
+}
+
+function echoRequester(status = 200) {
+    return createEchoRequester({ getURL: (url) => new URL(url), status });
+}
+
+export { createXhrRequester, echoRequester };

package/dist/src/createXhrRequester.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createXhrRequester.d.ts","sourceRoot":"","sources":["../../../../packages/requester-browser-xhr/src/createXhrRequester.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,SAAS,EAAY,MAAM,wBAAwB,CAAC;AAI9E,wBAAgB,kBAAkB,IAAI,SAAS,CAyE9C"}

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-browser-xhr/src/echoRequester.ts"],"names":[],"mappings":"AACA,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/createXhrRequester';
+export * from './src/echoRequester';

package/package.json

@@ -1,22 +1,35 @@
 {
   "name": "@algolia/requester-browser-xhr",
-  "version": "4.14.2",
-  "private": false,
+  "version": "5.0.0-alpha.3",
   "description": "Promise-based request library for browser using xhr.",
-  "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-browser-xhr.esm.js",
-  "types": "dist/requester-browser-xhr.d.ts",
+  "author": "Algolia",
+  "main": "dist/requester-browser-xhr.cjs.js",
+  "module": "dist/requester-browser-xhr.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",
+    "jest-environment-jsdom": "28.1.3",
+    "ts-jest": "28.0.5",
+    "typescript": "4.7.4",
+    "xhr-mock": "2.5.1"
+  },
+  "engines": {
+    "node": ">= 14.0.0"
   }
 }

package/src/__tests__/browser-xhr-requester.test.ts

@@ -0,0 +1,223 @@
+import type http from 'http';
+
+import type { EndRequest } from '@algolia/client-common';
+import type { MockRequest, MockResponse } from 'xhr-mock';
+import mock from 'xhr-mock';
+
+import { createXhrRequester } from '../..';
+import {
+  BASE_URL,
+  headers,
+  timeoutRequest,
+  requestStub,
+  getStringifiedBody,
+  createTestServer,
+} from '../../../../tests/utils';
+
+const requester = createXhrRequester();
+
+describe('status code handling', () => {
+  beforeEach(() => mock.setup());
+  afterEach(() => mock.teardown());
+
+  it('sends requests', async () => {
+    mock.post(BASE_URL, (req: MockRequest, res: MockResponse): MockResponse => {
+      expect(req.method()).toEqual('POST');
+      expect(req.header('content-type')).toEqual('text/plain');
+      expect(req.body()).toEqual(JSON.stringify({ foo: 'bar' }));
+
+      return res.status(200);
+    });
+
+    await requester.send(requestStub);
+  });
+
+  it('resolves status 200', async () => {
+    const body = getStringifiedBody();
+
+    mock.post(BASE_URL, {
+      status: 200,
+      body: requestStub.data,
+    });
+
+    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';
+
+    mock.post(BASE_URL, {
+      status: 300,
+      reason,
+    });
+
+    const response = await requester.send(requestStub);
+
+    expect(response.status).toBe(300);
+    expect(response.content).toBe(''); // No body returned here on xhr
+    expect(response.isTimedOut).toBe(false);
+  });
+
+  it('resolves status 400', async () => {
+    const body = getStringifiedBody({
+      message: 'Invalid Application-Id or API-Key',
+    });
+
+    mock.post(BASE_URL, {
+      status: 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 the protocol', async () => {
+    const body = getStringifiedBody();
+
+    mock.post('http://localhost/', {
+      status: 200,
+      body,
+    });
+
+    const response = await requester.send({
+      ...requestStub,
+      url: 'http://localhost',
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.content).toBe(body);
+    expect(response.isTimedOut).toBe(false);
+  });
+});
+
+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('connection 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(1990);
+    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(1990);
+    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,
+      responseTimeout: 6000,
+      url: 'http://localhost:1111',
+    });
+
+    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', () => {
+  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).toBe('Network request failed');
+    expect(response.isTimedOut).toBe(false);
+  });
+
+  it('resolves general network errors', async () => {
+    mock.post(BASE_URL, () =>
+      Promise.reject(new Error('This is a general error'))
+    );
+
+    const response = await requester.send(requestStub);
+
+    expect(response.status).toBe(0);
+    expect(response.content).toBe('Network request failed');
+    expect(response.isTimedOut).toBe(false);
+  });
+});

package/src/createXhrRequester.ts

@@ -0,0 +1,78 @@
+import type { EndRequest, Requester, Response } from '@algolia/client-common';
+
+type Timeout = ReturnType<typeof setTimeout>;
+
+export function createXhrRequester(): Requester {
+  function send(request: EndRequest): Promise<Response> {
+    return new Promise((resolve) => {
+      const baseRequester = new XMLHttpRequest();
+      baseRequester.open(request.method, request.url, true);
+
+      Object.keys(request.headers).forEach((key) =>
+        baseRequester.setRequestHeader(key, request.headers[key])
+      );
+
+      const createTimeout = (timeout: number, content: string): Timeout => {
+        return setTimeout(() => {
+          baseRequester.abort();
+
+          resolve({
+            status: 0,
+            content,
+            isTimedOut: true,
+          });
+        }, timeout);
+      };
+
+      const connectTimeout = createTimeout(
+        request.connectTimeout,
+        'Connection timeout'
+      );
+
+      let responseTimeout: Timeout | undefined;
+
+      baseRequester.onreadystatechange = (): void => {
+        if (
+          baseRequester.readyState > baseRequester.OPENED &&
+          responseTimeout === undefined
+        ) {
+          clearTimeout(connectTimeout);
+
+          responseTimeout = createTimeout(
+            request.responseTimeout,
+            'Socket timeout'
+          );
+        }
+      };
+
+      baseRequester.onerror = (): void => {
+        // istanbul ignore next
+        if (baseRequester.status === 0) {
+          clearTimeout(connectTimeout);
+          clearTimeout(responseTimeout!);
+
+          resolve({
+            content: baseRequester.responseText || 'Network request failed',
+            status: baseRequester.status,
+            isTimedOut: false,
+          });
+        }
+      };
+
+      baseRequester.onload = (): void => {
+        clearTimeout(connectTimeout);
+        clearTimeout(responseTimeout!);
+
+        resolve({
+          content: baseRequester.responseText,
+          status: baseRequester.status,
+          isTimedOut: false,
+        });
+      };
+
+      baseRequester.send(request.data);
+    });
+  }
+
+  return { send };
+}

package/src/echoRequester.ts

@@ -0,0 +1,6 @@
+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-browser-xhr.d.ts

@@ -1,5 +0,0 @@
-import { Requester } from '@algolia/requester-common';
-
-export declare function createBrowserXhrRequester(): Requester;
-
-export { }

package/dist/requester-browser-xhr.esm.js

@@ -1,57 +0,0 @@
-function createBrowserXhrRequester() {
-    return {
-        send(request) {
-            return new Promise((resolve) => {
-                const baseRequester = new XMLHttpRequest();
-                baseRequester.open(request.method, request.url, true);
-                Object.keys(request.headers).forEach(key => baseRequester.setRequestHeader(key, request.headers[key]));
-                const createTimeout = (timeout, content) => {
-                    return setTimeout(() => {
-                        baseRequester.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;
-                // eslint-disable-next-line functional/immutable-data
-                baseRequester.onreadystatechange = () => {
-                    if (baseRequester.readyState > baseRequester.OPENED && responseTimeout === undefined) {
-                        clearTimeout(connectTimeout);
-                        responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
-                    }
-                };
-                // eslint-disable-next-line functional/immutable-data
-                baseRequester.onerror = () => {
-                    // istanbul ignore next
-                    if (baseRequester.status === 0) {
-                        clearTimeout(connectTimeout);
-                        clearTimeout(responseTimeout);
-                        resolve({
-                            content: baseRequester.responseText || 'Network request failed',
-                            status: baseRequester.status,
-                            isTimedOut: false,
-                        });
-                    }
-                };
-                //  eslint-disable-next-line functional/immutable-data
-                baseRequester.onload = () => {
-                    clearTimeout(connectTimeout);
-                    clearTimeout(responseTimeout);
-                    resolve({
-                        content: baseRequester.responseText,
-                        status: baseRequester.status,
-                        isTimedOut: false,
-                    });
-                };
-                baseRequester.send(request.data);
-            });
-        },
-    };
-}
-
-export { createBrowserXhrRequester };

package/index.js

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