feat(fetch-requester): add @algolia/requester-fetch (#1411)

* feat(fetch-requester): add `@algolia/requester-fetch`
* chore: unpin cross-fetch
Co-authored-by: Haroen Viaene <fingebimus@me.com>

Author: ykzts

.eslintrc.js

@@ -70,6 +70,7 @@ module.exports = {
 ['@algolia/recommend','./packages/recommend/src'],
 ['@algolia/requester-browser-xhr','./packages/requester-browser-xhr/src'],
 ['@algolia/requester-common','./packages/requester-common/src'],
+['@algolia/requester-fetch','./packages/requester-fetch/src'],
 ['@algolia/requester-node-http','./packages/requester-node-http/src'],
 ['@algolia/transporter','./packages/transporter/src'],
 ],

jest.config.js

@@ -83,6 +83,7 @@ module.exports = {
 testEnvironment: 'node',
 testPathIgnorePatterns: [
 'packages/requester-browser-xhr/*',
+'packages/requester-fetch/*',
 'packages/cache-browser-local-storage/*',
 'packages/algoliasearch/src/__tests__/lite.test.ts',
 ],

package.json

@@ -50,6 +50,7 @@
 "@wdio/static-server-service": "5.16.10",
 "barrelsby": "2.2.0",
 "bundlesize": "0.18.0",
+"cross-fetch": "3.1.5",
 "dotenv": "8.2.0",
 "eslint": "6.8.0",
 "eslint-config-algolia": "15.0.0",

packages/requester-fetch/api-extractor.json

@@ -0,0 +1,7 @@
+{
+"extends": "../../api-extractor.json",
+"mainEntryPointFilePath": "./dist/packages/<unscopedPackageName>/src/index.d.ts",
+"dtsRollup": {
+"untrimmedFilePath": "./dist/<unscopedPackageName>.d.ts"
+ }
+}

packages/requester-fetch/index.js

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

packages/requester-fetch/package.json

@@ -0,0 +1,22 @@
+{
+"name": "@algolia/requester-fetch",
+"version": "4.13.1",
+"private": false,
+"description": "Promise-based request library for Fetch.",
+"repository": {
+"type": "git",
+"url": "git://github.com/algolia/algoliasearch-client-javascript.git"
+ },
+"license": "MIT",
+"sideEffects": false,
+"main": "index.js",
+"module": "dist/requester-fetch.esm.js",
+"types": "dist/requester-fetch.d.ts",
+"files": [
+"index.js",
+"dist"
+ ],
+"dependencies": {
+"@algolia/requester-common": "4.13.1"
+ }
+}

packages/requester-fetch/src/__tests__/unit/fetch-requester.test.ts

@@ -0,0 +1,270 @@
+import{MethodEnum,Request}from'@algolia/requester-common';
+importcrossFetchfrom'cross-fetch';
+importnockfrom'nock';
+// @ts-ignore
+import{Readable}from'readable-stream';
+
+import{createFetchRequester}from'../..';
+
+constoriginalFetch=window.fetch;
+
+beforeEach(()=>{
+window.fetch=crossFetch;
+});
+
+afterEach(()=>{
+window.fetch=originalFetch;
+});
+
+constrequester=createFetchRequester();
+
+constheaders={
+'content-type': 'application/x-www-form-urlencoded',
+};
+
+consttimeoutRequest: Request={
+url: 'missing-url-here',
+data: '',
+headers: {},
+method: 'GET',
+responseTimeout: 5,
+connectTimeout: 2,
+};
+
+constrequestStub: Request={
+url: 'https://algolia-dns.net/foo?x-algolia-header=foo',
+method: MethodEnum.Post,
+headers: {
+'Content-Type': 'application/x-www-form-urlencoded',
+},
+data: JSON.stringify({foo: 'bar'}),
+responseTimeout: 2,
+connectTimeout: 1,
+};
+
+describe('status code handling',()=>{
+it('sends requests',async()=>{
+constbody=JSON.stringify({foo: 'bar'});
+
+nock('https://algolia-dns.net',{reqheaders: headers})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.reply(200,body);
+
+constresponse=awaitrequester.send(requestStub);
+
+expect(response.content).toEqual(JSON.stringify({foo: 'bar'}));
+});
+
+it('resolves status 200',async()=>{
+constbody=JSON.stringify({foo: 'bar'});
+
+nock('https://algolia-dns.net',{reqheaders: headers})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.reply(200,body);
+
+constresponse=awaitrequester.send(requestStub);
+
+expect(response.status).toBe(200);
+expect(response.content).toBe(body);
+expect(response.isTimedOut).toBe(false);
+});
+
+it('resolves status 300',async()=>{
+constreason='Multiple Choices';
+
+nock('https://algolia-dns.net',{reqheaders: headers})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.reply(300,reason);
+
+constresponse=awaitrequester.send(requestStub);
+
+expect(response.status).toBe(300);
+expect(response.content).toBe(reason);
+expect(response.isTimedOut).toBe(false);
+});
+
+it('resolves status 400',async()=>{
+constbody={message: 'Invalid Application-Id or API-Key'};
+
+nock('https://algolia-dns.net',{reqheaders: headers})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.reply(400,JSON.stringify(body));
+
+constresponse=awaitrequester.send(requestStub);
+
+expect(response.status).toBe(400);
+expect(response.content).toBe(JSON.stringify(body));
+expect(response.isTimedOut).toBe(false);
+});
+
+it('handles chunked responses inside unicode character boundaries',async()=>{
+consttestdata=Buffer.from('äöü');
+
+// create a test response stream that is chunked inside a unicode character
+function*generate(){
+yieldtestdata.slice(0,3);
+yieldtestdata.slice(3);
+}
+
+consttestStream=Readable.from(generate());
+
+nock('https://algolia-dns.net',{reqheaders: headers})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.reply(200,testStream);
+
+constresponse=awaitrequester.send(requestStub);
+
+expect(response.content).toEqual(testdata.toString());
+});
+});
+
+describe('timeout handling',()=>{
+it('timeouts with the given 1 seconds connection timeout',async()=>{
+constbefore=Date.now();
+constresponse=awaitrequester.send({
+ ...timeoutRequest,
+ ...{connectTimeout: 1,url: 'http://www.google.com:81'},
+});
+
+constnow=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()=>{
+constbefore=Date.now();
+constresponse=awaitrequester.send({
+ ...timeoutRequest,
+ ...{connectTimeout: 2,url: 'http://www.google.com:81'},
+});
+
+constnow=Date.now();
+
+expect(response.content).toBe('Connection timeout');
+expect(now-before).toBeGreaterThan(1999);
+expect(now-before).toBeLessThan(2200);
+});
+
+it('socket timeouts if response dont appears before the timeout with 2 seconds timeout',async()=>{
+constbefore=Date.now();
+
+constresponse=awaitrequester.send({
+ ...timeoutRequest,
+ ...{responseTimeout: 2,url: 'http://localhost:1111/'},
+});
+
+constnow=Date.now();
+
+expect(now-before).toBeGreaterThan(1999);
+expect(now-before).toBeLessThan(2200);
+expect(response.content).toBe('Socket timeout');
+});
+
+it('socket timeouts if response dont appears before the timeout with 3 seconds timeout',async()=>{
+constbefore=Date.now();
+constresponse=awaitrequester.send({
+ ...timeoutRequest,
+ ...{
+responseTimeout: 3,
+url: 'http://localhost:1111',
+},
+});
+
+constnow=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()=>{
+constrequest=Object.assign({},requestStub);
+constbefore=Date.now();
+constresponse=awaitrequester.send({
+ ...request,
+url: 'http://localhost:1111',
+responseTimeout: 6,// the fake server sleeps for 5 seconds...
+});
+
+constnow=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);
+});
+});
+
+describe('error handling',(): void=>{
+it('resolves dns not found',async()=>{
+constrequest={
+url: 'https://this-dont-exist.algolia.com',
+method: MethodEnum.Post,
+headers: {
+'X-Algolia-Application-Id': 'ABCDE',
+'X-Algolia-API-Key': '12345',
+'Content-Type': 'application/x-www-form-urlencoded',
+},
+data: JSON.stringify({foo: 'bar'}),
+responseTimeout: 2,
+connectTimeout: 1,
+};
+
+constresponse=awaitrequester.send(request);
+
+expect(response.status).toBe(0);
+expect(response.content).toContain('');
+expect(response.isTimedOut).toBe(false);
+});
+
+it('resolves general network errors',async()=>{
+nock('https://algolia-dns.net',{reqheaders: headers})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.replyWithError('This is a general error');
+
+constresponse=awaitrequester.send(requestStub);
+
+expect(response.status).toBe(0);
+expect(response.content).toBe(
+'request to https://algolia-dns.net/foo?x-algolia-header=foo failed, reason: This is a general error'
+);
+expect(response.isTimedOut).toBe(false);
+});
+});
+
+describe('requesterOptions',()=>{
+it('allows to pass requesterOptions',async()=>{
+constbody=JSON.stringify({foo: 'bar'});
+constrequesterTmp=createFetchRequester({
+requesterOptions: {
+headers: {
+'x-algolia-foo': 'bar',
+},
+},
+});
+
+nock('https://algolia-dns.net',{
+reqheaders: {
+ ...headers,
+'x-algolia-foo': 'bar',
+},
+})
+.post('/foo')
+.query({'x-algolia-header': 'foo'})
+.reply(200,body);
+
+constresponse=awaitrequesterTmp.send(requestStub);
+
+expect(response.status).toBe(200);
+expect(response.content).toBe(body);
+});
+});