#526

Build # #526

Build Type

push

Committed by

Commit Message

<a href="https://github.com/Vermonster/fhir-kit-client/commit/<a class=hub.com/Vermonster/fhir-kit-client/commit/f20b28df8ef29f8fcc854bfaee1867d4a2b88ee3">f20b28df8<a href="https://github.com/Vermonster/fhir-kit-client/commit/f20b28df8ef29f8fcc854bfaee1867d4a2b88ee3">">Merge </a><a class="double-link" href="https://github.com/Vermonster/fhir-kit-client/commit/<a class="double-link" href="https://github.com/Vermonster/fhir-kit-client/commit/3dd56e641060a8bd13b74b96b2792fda5571a342">3dd56e641</a>">3dd56e641</a><a href="https://github.com/Vermonster/fhir-kit-client/commit/f20b28df8ef29f8fcc854bfaee1867d4a2b88ee3"> into 46ab8bc4f">46ab8bc4f</a>

Run Details

188 of 217 branches covered (86.64%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 2 files covered. (100.0%)

329 of 341 relevant lines covered (96.48%)

23.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.55

/lib/http-client.js

/* global Request, Headers */
require('es6-promise').polyfill();
require('cross-fetch/polyfill');

const { logRequestError, logRequestInfo, logResponseInfo } = require('./logging');

const defaultHeaders = { accept: 'application/fhir+json' };

const responseAttributeKey = '__response';
const requestAttributeKey = '__request';

let agentIsAvailable = false;
let HttpAgent;
let HttpsAgent;

/* eslint-disable global-require */
try {
  HttpAgent = require('agentkeepalive');
  // eslint-disable-next-line prefer-destructuring
  HttpsAgent = require('agentkeepalive').HttpsAgent;
  agentIsAvailable = true;
} catch (_e) {
  logRequestInfo('HTTP Agent is not available');
}
/* eslint-enable global-require */

// Create and cache the agent per base URL and options:
const agentCache = new WeakMap();
function agentBuilder(baseUrl, agentOptions = {}) {
  const key = { baseUrl, agentOptions };

  if (!agentIsAvailable) { return {}; }
  if (agentCache.get(key)) { return agentCache.get(key); }

  if (baseUrl.startsWith('https')) {
    agentCache.set(key, { agent: new HttpsAgent(agentOptions) });
  } else {
    agentCache.set(key, { agent: new HttpAgent(agentOptions) });
  }
  return agentCache.get(key);
}

function responseErrorBuilder({
  status,
  data,
  method,
  headers,
  url,
}) {
  const error = {
    response: {
      status,
      data,
    },
    config: {
      method,
      url,
      headers,
    },
  };

  logRequestError(error);
  return error;
}

function stringifyBody(body) {
  if (typeof body === 'string') {
    return body;
  }
  return JSON.stringify(body);
}

/**
 * Class used by Client to make HTTP requests. Do not use this class directly,
 * use Client#read, Client#create, etc.
 *
 * @private
 */
module.exports = class HttpClient {
  // Utility to lowercase 1st level keys in an object.
  static lcKeys(obj) {
    return obj
      ? Object.keys(obj).reduce((acc, key) => {
        acc[key.toLowerCase()] = obj[key];
        return acc;
      }, {})
      : obj;
  }

  /**
   * Create an HTTP client.
   *
   * @param {Object} config HTTP Client configuration
   * @param {String} config.baseUrl Base URL used to resolve relative paths
   * @param {Object} [config.customHeaders] Custom headers to send for all
   *                 requests
   * @param {Object} [config.requestOptions] Additional options for fetch/agent
   * @param {Function} [config.requestSigner] Optional pass in a function to sign the request.
   * @throws An error will be thrown on unsuccessful requests.
   */
  constructor({ baseUrl, customHeaders = {}, requestOptions = {}, requestSigner = undefined }) {
    this.baseUrl = baseUrl;
    this.customHeaders = customHeaders;
    this.baseRequestOptions = requestOptions;
    this.requestSigner = requestSigner;
  }

  set baseUrl(url) {
    if (!url) {
      throw new Error('baseUrl cannot be blank');
    }
    if (typeof url !== 'string') {
      throw new Error('baseUrl must be a string');
    }
    this.baseUrlValue = url;
  }

  get baseUrl() {
    return this.baseUrlValue;
  }

  static responseFor(requestResponse) {
    return requestResponse[responseAttributeKey];
  }

  static requestFor(requestResponse) {
    return requestResponse[requestAttributeKey];
  }

  set bearerToken(token) {
    const header = `Bearer ${token}`;
    this.authHeader = { authorization: header };
  }

  requestBuilder(method, url, options, body) {
    const requestOptions = {
      ...this.baseRequestOptions,
      ...options,
      method,
      body: stringifyBody(body),
    };

    let keepalive = {};
    if (!agentIsAvailable) {
      const keepAliveDefined = Object.prototype.hasOwnProperty.call(
        requestOptions, 'keepalive',
      );
      keepalive = {
        keepalive: keepAliveDefined ? requestOptions.keepalive : true,
      };
    }

    Object.assign(requestOptions,
      keepalive,
      { headers: new Headers(this.mergeHeaders(options.headers)) },
      agentBuilder(this.baseUrl, requestOptions));

    if (this.requestSigner) {
      this.requestSigner(url, requestOptions);
    }
    return new Request(url, requestOptions);
  }

  async request(method, requestUrl, options = {}, body) {
    const url = this.expandUrl(requestUrl);

    const request = this.requestBuilder(method, url, options, body);
    logRequestInfo(method, url, request.headers);

    const response = await fetch(request);
    const { status, headers } = response;
    logResponseInfo({ status, response });

    const bodyText = await response.text();

    let data = {};
    if (bodyText) {
      try {
        data = JSON.parse(bodyText);
      } catch (_error) {
        data = bodyText;
        throw responseErrorBuilder({ status, data, method, headers, url });
      }
    }

    if (!response.ok) {
      throw responseErrorBuilder({ status, data, method, headers, url });
    }

    // Add __response and __request
    Object.defineProperty(data, responseAttributeKey, {
      writable: false,
      enumerable: false,
      value: response,
    });

    Object.defineProperty(data, requestAttributeKey, {
      writable: false,
      enumerable: false,
      value: request,
    });

    return data;
  }

  async get(url, options) {
    return this.request('GET', url, options);
  }

  async delete(url, options) {
    return this.request('DELETE', url, options);
  }

  async put(url, body, options = {}) {
    const headers = {
      ...{ 'content-type': 'application/fhir+json' },
      ...HttpClient.lcKeys(options.headers),
    };
    const putOptions = { ...options, headers };

    return this.request('PUT', url, putOptions, body);
  }

  async post(url, body, options = {}) {
    const headers = {
      ...{ 'content-type': 'application/fhir+json' },
      ...HttpClient.lcKeys(options.headers),
    };
    const postOptions = { ...options, headers };

    return this.request('POST', url, postOptions, body);
  }

  async patch(url, body, options) {
    return this.request('PATCH', url, options, body);
  }

  expandUrl(url = '') {
    if (url.toLowerCase().startsWith('http')) {
      return url;
    }
    if (this.baseUrl.endsWith('/') && url.startsWith('/')) {
      return this.baseUrl + url.slice(1);
    }
    if (this.baseUrl.endsWith('/') || url.startsWith('/')) {
      return this.baseUrl + url;
    }
    return `${this.baseUrl}/${url}`;
  }

  mergeHeaders(requestHeaders) {
    const { lcKeys } = HttpClient;

    return {
      ...lcKeys(defaultHeaders),
      ...lcKeys(this.authHeader),
      ...lcKeys(this.customHeaders),
      ...lcKeys(requestHeaders),
    };
  }
};

1	/* global Request, Headers */
2	require('es6-promise').polyfill();	1✔
3	require('cross-fetch/polyfill');	1✔
4
5	const { logRequestError, logRequestInfo, logResponseInfo } = require('./logging');	1✔
6
7	const defaultHeaders = { accept: 'application/fhir+json' };	1✔
8
9	const responseAttributeKey = '__response';	1✔
10	const requestAttributeKey = '__request';	1✔
11
12	let agentIsAvailable = false;	1✔
13	let HttpAgent;
14	let HttpsAgent;
15
16	/* eslint-disable global-require */
17	try {	1✔
18	HttpAgent = require('agentkeepalive');	1✔
19	// eslint-disable-next-line prefer-destructuring
20	HttpsAgent = require('agentkeepalive').HttpsAgent;	1✔
21	agentIsAvailable = true;	1✔
22	} catch (_e) {
23	logRequestInfo('HTTP Agent is not available');	×
24	}
25	/* eslint-enable global-require */
26
27	// Create and cache the agent per base URL and options:
28	const agentCache = new WeakMap();	1✔
29	function agentBuilder(baseUrl, agentOptions = {}) {	×
30	const key = { baseUrl, agentOptions };	104✔
31
32	if (!agentIsAvailable) { return {}; }	104!
33	if (agentCache.get(key)) { return agentCache.get(key); }	104!
34
35	if (baseUrl.startsWith('https')) {	104✔
36	agentCache.set(key, { agent: new HttpsAgent(agentOptions) });	92✔
37	} else {
38	agentCache.set(key, { agent: new HttpAgent(agentOptions) });	12✔
39	}
40	return agentCache.get(key);	104✔
41	}
42
43	function responseErrorBuilder({
44	status,
45	data,
46	method,
47	headers,
48	url,
49	}) {
50	const error = {	21✔
51	response: {
52	status,
53	data,
54	},
55	config: {
56	method,
57	url,
58	headers,
59	},
60	};
61
62	logRequestError(error);	21✔
63	return error;	21✔
64	}
65
66	function stringifyBody(body) {
67	if (typeof body === 'string') {	104✔
68	return body;	3✔
69	}
70	return JSON.stringify(body);	101✔
71	}
72
73	/**
74	* Class used by Client to make HTTP requests. Do not use this class directly,
75	* use Client#read, Client#create, etc.
76	*
77	* @private
78	*/
79	module.exports = class HttpClient {	1✔
80	// Utility to lowercase 1st level keys in an object.
81	static lcKeys(obj) {
82	return obj	439✔
83	? Object.keys(obj).reduce((acc, key) => {
84	acc[key.toLowerCase()] = obj[key];	171✔
85	return acc;	171✔
86	}, {})
87	: obj;
88	}
89
90	/**
91	* Create an HTTP client.
92	*
93	* @param {Object} config HTTP Client configuration
94	* @param {String} config.baseUrl Base URL used to resolve relative paths
95	* @param {Object} [config.customHeaders] Custom headers to send for all
96	* requests
97	* @param {Object} [config.requestOptions] Additional options for fetch/agent
98	* @param {Function} [config.requestSigner] Optional pass in a function to sign the request.
99	* @throws An error will be thrown on unsuccessful requests.
100	*/
101	constructor({ baseUrl, customHeaders = {}, requestOptions = {}, requestSigner = undefined }) {	398✔
102	this.baseUrl = baseUrl;	134✔
103	this.customHeaders = customHeaders;	132✔
104	this.baseRequestOptions = requestOptions;	132✔
105	this.requestSigner = requestSigner;	132✔
106	}
107
108	set baseUrl(url) {
109	if (!url) {	135✔
110	throw new Error('baseUrl cannot be blank');	2✔
111	}
112	if (typeof url !== 'string') {	133✔
113	throw new Error('baseUrl must be a string');	1✔
114	}
115	this.baseUrlValue = url;	132✔
116	}
117
118	get baseUrl() {
119	return this.baseUrlValue;	374✔
120	}
121
122	static responseFor(requestResponse) {
123	return requestResponse[responseAttributeKey];	3✔
124	}
125
126	static requestFor(requestResponse) {
127	return requestResponse[requestAttributeKey];	3✔
128	}
129
130	set bearerToken(token) {
131	const header = `Bearer ${token}`;	2✔
132	this.authHeader = { authorization: header };	2✔
133	}
134
135	requestBuilder(method, url, options, body) {
136	const requestOptions = {	104✔
137	...this.baseRequestOptions,
138	...options,
139	method,
140	body: stringifyBody(body),
141	};
142
143	let keepalive = {};	104✔
144	if (!agentIsAvailable) {	104!
145	const keepAliveDefined = Object.prototype.hasOwnProperty.call(	×
146	requestOptions, 'keepalive',
147	);
148	keepalive = {	×
149	keepalive: keepAliveDefined ? requestOptions.keepalive : true,	×
150	};
151	}
152
153	Object.assign(requestOptions,	104✔
154	keepalive,
155	{ headers: new Headers(this.mergeHeaders(options.headers)) },
156	agentBuilder(this.baseUrl, requestOptions));
157
158	if (this.requestSigner) {	104✔
159	this.requestSigner(url, requestOptions);	3✔
160	}
161	return new Request(url, requestOptions);	104✔
162	}
163
164	async request(method, requestUrl, options = {}, body) {	×
165	const url = this.expandUrl(requestUrl);	104✔
166
167	const request = this.requestBuilder(method, url, options, body);	104✔
168	logRequestInfo(method, url, request.headers);	104✔
169
170	const response = await fetch(request);	104✔
171	const { status, headers } = response;	97✔
172	logResponseInfo({ status, response });	97✔
173
174	const bodyText = await response.text();	97✔
175
176	let data = {};	97✔
177	if (bodyText) {	97✔
178	try {	75✔
179	data = JSON.parse(bodyText);	75✔
180	} catch (_error) {
181	data = bodyText;	1✔
182	throw responseErrorBuilder({ status, data, method, headers, url });	1✔
183	}
184	}
185
186	if (!response.ok) {	96✔
187	throw responseErrorBuilder({ status, data, method, headers, url });	20✔
188	}
189
190	// Add __response and __request
191	Object.defineProperty(data, responseAttributeKey, {	76✔
192	writable: false,
193	enumerable: false,
194	value: response,
195	});
196
197	Object.defineProperty(data, requestAttributeKey, {	76✔
198	writable: false,
199	enumerable: false,
200	value: request,
201	});
202
203	return data;	76✔
204	}
205
206	async get(url, options) {
207	return this.request('GET', url, options);	59✔
208	}
209
210	async delete(url, options) {
211	return this.request('DELETE', url, options);	4✔
212	}
213
214	async put(url, body, options = {}) {	×
215	const headers = {	4✔
216	...{ 'content-type': 'application/fhir+json' },
217	...HttpClient.lcKeys(options.headers),
218	};
219	const putOptions = { ...options, headers };	4✔
220
221	return this.request('PUT', url, putOptions, body);	4✔
222	}
223
224	async post(url, body, options = {}) {	×
225	const headers = {	19✔
226	...{ 'content-type': 'application/fhir+json' },
227	...HttpClient.lcKeys(options.headers),
228	};
229	const postOptions = { ...options, headers };	19✔
230
231	return this.request('POST', url, postOptions, body);	19✔
232	}
233
234	async patch(url, body, options) {
235	return this.request('PATCH', url, options, body);	4✔
236	}
237
238	expandUrl(url = '') {	2✔
239	if (url.toLowerCase().startsWith('http')) {	104✔
240	return url;	17✔
241	}
242	if (this.baseUrl.endsWith('/') && url.startsWith('/')) {	87!
243	return this.baseUrl + url.slice(1);	×
244	}
245	if (this.baseUrl.endsWith('/') \|\| url.startsWith('/')) {	87✔
246	return this.baseUrl + url;	23✔
247	}
248	return `${this.baseUrl}/${url}`;	64✔
249	}
250
251	mergeHeaders(requestHeaders) {
252	const { lcKeys } = HttpClient;	104✔
253
254	return {	104✔
255	...lcKeys(defaultHeaders),
256	...lcKeys(this.authHeader),
257	...lcKeys(this.customHeaders),
258	...lcKeys(requestHeaders),
259	};
260	}
261	};

Vermonster / fhir-kit-client / #526

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous