RestClient.ts

/*
 * Copyright 2017-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
 * the License. A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
 * and limitations under the License.
 */

import {
	ConsoleLogger as Logger,
	Signer,
	Platform,
	Credentials,
} from '@aws-amplify/core';

import { RestClientOptions, AWSCredentials, apiOptions } from './types';
import axios from 'axios';

const logger = new Logger('RestClient'),
	urlLib = require('url');

/**
* HTTP Client for REST requests. Send and receive JSON data.
* Sign request with AWS credentials if available
* Usage:
<pre>
const restClient = new RestClient();
restClient.get('...')
    .then(function(data) {
        console.log(data);
    })
    .catch(err => console.log(err));
</pre>
*/
export class RestClient {
	private _options;
	private _region: string = 'us-east-1'; // this will be updated by endpoint function
	private _service: string = 'execute-api'; // this can be updated by endpoint function
	private _custom_header = undefined; // this can be updated by endpoint function
	/**
	 * @param {RestClientOptions} [options] - Instance options
	 */
	constructor(options: apiOptions) {
		const { endpoints } = options;
		this._options = options;
		logger.debug('API Options', this._options);
	}

	/**
    * Update AWS credentials
    * @param {AWSCredentials} credentials - AWS credentials
    *
    updateCredentials(credentials: AWSCredentials) {
        this.options.credentials = credentials;
    }
*/
	/**
	 * Basic HTTP request. Customizable
	 * @param {string} url - Full request URL
	 * @param {string} method - Request HTTP method
	 * @param {json} [init] - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	async ajax(url: string, method: string, init) {
		logger.debug(method + ' ' + url);

		const parsed_url = this._parseUrl(url);

		const params = {
			method,
			url,
			host: parsed_url.host,
			path: parsed_url.path,
			headers: {},
			data: null,
			responseType: 'json',
			timeout: 0,
		};

		let libraryHeaders = {};

		if (Platform.isReactNative) {
			const userAgent = Platform.userAgent || 'aws-amplify/0.1.x';
			libraryHeaders = {
				'User-Agent': userAgent,
			};
		}

		const initParams = Object.assign({}, init);
		const isAllResponse = initParams.response;
		if (initParams.body) {
			libraryHeaders['Content-Type'] = 'application/json; charset=UTF-8';
			params.data = JSON.stringify(initParams.body);
		}
		if (initParams.responseType) {
			params.responseType = initParams.responseType;
		}
		if (initParams.withCredentials) {
			params['withCredentials'] = initParams.withCredentials;
		}
		if (initParams.timeout) {
			params.timeout = initParams.timeout;
		}

		params['signerServiceInfo'] = initParams.signerServiceInfo;

		// custom_header callback
		const custom_header = this._custom_header
			? await this._custom_header()
			: undefined;

		params.headers = {
			...libraryHeaders,
			...custom_header,
			...initParams.headers,
		};

		// Intentionally discarding search
		const { search, ...parsedUrl } = urlLib.parse(url, true, true);
		params.url = urlLib.format({
			...parsedUrl,
			query: {
				...parsedUrl.query,
				...(initParams.queryStringParameters || {}),
			},
		});

		// Do not sign the request if client has added 'Authorization' header,
		// which means custom authorizer.
		if (typeof params.headers['Authorization'] !== 'undefined') {
			params.headers = Object.keys(params.headers).reduce((acc, k) => {
				if (params.headers[k]) {
					acc[k] = params.headers[k];
				}
				return acc;
				// tslint:disable-next-line:align
			}, {});
			return this._request(params, isAllResponse);
		}

		// Signing the request in case there credentials are available
		return Credentials.get().then(
			credentials => this._signed({ ...params }, credentials, isAllResponse),
			err => {
				logger.debug('No credentials available, the request will be unsigned');
				return this._request(params, isAllResponse);
			}
		);
	}

	/**
	 * GET HTTP request
	 * @param {string} url - Full request URL
	 * @param {JSON} init - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	get(url: string, init) {
		return this.ajax(url, 'GET', init);
	}

	/**
	 * PUT HTTP request
	 * @param {string} url - Full request URL
	 * @param {json} init - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	put(url: string, init) {
		return this.ajax(url, 'PUT', init);
	}

	/**
	 * PATCH HTTP request
	 * @param {string} url - Full request URL
	 * @param {json} init - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	patch(url: string, init) {
		return this.ajax(url, 'PATCH', init);
	}

	/**
	 * POST HTTP request
	 * @param {string} url - Full request URL
	 * @param {json} init - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	post(url: string, init) {
		return this.ajax(url, 'POST', init);
	}

	/**
	 * DELETE HTTP request
	 * @param {string} url - Full request URL
	 * @param {json} init - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	del(url: string, init) {
		return this.ajax(url, 'DELETE', init);
	}

	/**
	 * HEAD HTTP request
	 * @param {string} url - Full request URL
	 * @param {json} init - Request extra params
	 * @return {Promise} - A promise that resolves to an object with response status and JSON data, if successful.
	 */
	head(url: string, init) {
		return this.ajax(url, 'HEAD', init);
	}

	/**
	 * Getting endpoint for API
	 * @param {string} apiName - The name of the api
	 * @return {string} - The endpoint of the api
	 */
	endpoint(apiName: string) {
		const cloud_logic_array = this._options.endpoints;
		let response = '';

		if (!Array.isArray(cloud_logic_array)) {
			return response;
		}

		cloud_logic_array.forEach(v => {
			if (v.name === apiName) {
				response = v.endpoint;
				if (typeof v.region === 'string') {
					this._region = v.region;
				} else if (typeof this._options.region === 'string') {
					this._region = this._options.region;
				}
				if (typeof v.service === 'string') {
					this._service = v.service || 'execute-api';
				} else {
					this._service = 'execute-api';
				}
				if (typeof v.custom_header === 'function') {
					this._custom_header = v.custom_header;
				} else {
					this._custom_header = undefined;
				}
			}
		});
		return response;
	}

	/** private methods **/

	private _signed(params, credentials, isAllResponse) {
		const {
			signerServiceInfo: signerServiceInfoParams,
			...otherParams
		} = params;

		const endpoint_region: string = this._region || this._options.region;
		const endpoint_service: string = this._service || this._options.service;

		const creds = {
			secret_key: credentials.secretAccessKey,
			access_key: credentials.accessKeyId,
			session_token: credentials.sessionToken,
		};

		const endpointInfo = {
			region: endpoint_region,
			service: endpoint_service,
		};

		const signerServiceInfo = Object.assign(
			endpointInfo,
			signerServiceInfoParams
		);

		const signed_params = Signer.sign(otherParams, creds, signerServiceInfo);

		if (signed_params.data) {
			signed_params.body = signed_params.data;
		}

		logger.debug('Signed Request: ', signed_params);

		delete signed_params.headers['host'];
		return axios(signed_params)
			.then(response => (isAllResponse ? response : response.data))
			.catch(error => {
				logger.debug(error);
				throw error;
			});
	}

	private _request(params, isAllResponse = false) {
		return axios(params)
			.then(response => (isAllResponse ? response : response.data))
			.catch(error => {
				logger.debug(error);
				throw error;
			});
	}

	private _parseUrl(url) {
		const parts = url.split('/');

		return {
			host: parts[2],
			path: '/' + parts.slice(3).join('/'),
		};
	}
}