8795033128

Committed 23 Apr 2024 04:55AM UTC coverage: 92.657% (-0.8%) from 93.418%

Build # 8795033128

Build Type

Pull #254

github

Committed by

SushilMallRC

Commit Message

Add comments on public methods

Pull Request Pull Request #254: Add Comments for methods, classes and interface.

Run Details

575 of 703 branches covered (81.79%)

Branch coverage included in aggregate %.

74 of 87 new or added lines in 4 files covered. (85.06%)

26 existing lines in 4 files now uncovered.

1974 of 2048 relevant lines covered (96.39%)

41.77 hits per line

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

87.5

/sdk/src/http/Client.ts

import {EventEmitter} from 'events';
import isPlainObject from 'is-plain-object';

import Externals from '../core/Externals';
import {objectToUrlParams} from './utils';

function findHeaderName(name, headers) {
    name = name.toLowerCase();
    return Object.keys(headers).reduce((res, key) => {
        if (res) {
            return res;
        }
        if (name === key.toLowerCase()) {
            return key;
        }
        return res;
    }, null);
}

export interface ApiError extends Error {
    originalMessage?: string;
    response?: Response;
    request?: Request;
}

export interface ClientOptions {
    externals: Externals;
    defaultRequestInit: CreateRequestOptions;
}

export enum events {
    beforeRequest = 'beforeRequest',
    requestSuccess = 'requestSuccess',
    requestError = 'requestError',
}

export default class Client extends EventEmitter {
    public static _contentType = 'Content-Type';

    public static _jsonContentType = 'application/json';

    public static _multipartContentType = 'multipart/mixed';

    public static _urlencodedContentType = 'application/x-www-form-urlencoded';

    public static _headerSeparator = ':';

    public static _bodySeparator = '\n\n';

    public static _boundarySeparator = '--';

    public static _unauthorizedStatus = 401;

    public static _rateLimitStatus = 429;

    public static _allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];

    public static _defaultRequestInit: CreateRequestOptions = {
        credentials: 'include',
        mode: 'cors',
    };

    public events = events;

    private _externals: Externals;

    private _defaultRequestInit: CreateRequestOptions = {};

    public constructor({externals, defaultRequestInit = {}}: ClientOptions) {
        super();
        this._defaultRequestInit = defaultRequestInit;
        this._externals = externals;
    }

    /**
     * Send a request and handle the response asynchronously.
     * @param {Request} request - The request to send.
     * @returns {Promise<Response>} - A promise resolving to the response.
     */
    public async sendRequest(request: Request): Promise<Response> {
        let response;
        try {
            //TODO Stop request if listeners return false
            this.emit(this.events.beforeRequest, request);

            response = await this._loadResponse(request);

            if (!response.ok) {
                throw new Error('Response has unsuccessful status');
            }

            this.emit(this.events.requestSuccess, response, request);

            return response;
        } catch (e) {
            const error = !e.response ? await this.makeError(e, response, request) : e;

            this.emit(this.events.requestError, error);

            throw error;
        }
    }

    public async _loadResponse(request: Request): Promise<Response> {
        return this._externals.fetch.call(null, request); // fixed illegal invocation in Chrome
    }

    /**
     * Wraps the JS Error object with transaction information
     */
    public async makeError(e: any, response: Response = null, request: Request = null): Promise<ApiError> {
        // Wrap only if regular error
        if (!e.response && !e.originalMessage) {
            e.response = response;
            e.request = request;
            e.originalMessage = e.message;
            e.message = (response && (await this.error(response, true))) || e.originalMessage;
        }

        return e;
    }

    public createRequest(init: CreateRequestOptions = Client._defaultRequestInit): Request {
        init = {...this._defaultRequestInit, ...init};
        init.headers = init.headers || {};

        // Sanity checks
        if (!init.url) {
            throw new Error('Url is not defined');
        }
        if (!init.method) {
            init.method = 'GET';
        }
        init.method = init.method.toUpperCase();
        if (init.method && Client._allowedMethods.indexOf(init.method) < 0) {
            throw new Error(`Method has wrong value: ${init.method}`);
        }

        // Defaults
        init.credentials = init.credentials || 'include';
        init.mode = init.mode || 'cors';

        // Append Query String
        if (init.query) {
            init.url = init.url + (init.url.includes('?') ? '&' : '?') + objectToUrlParams(init.query);
        }
        // Serialize body
        if (isPlainObject(init.body) || !init.body) {
            let contentTypeHeaderName = findHeaderName(Client._contentType, init.headers);

            if (!contentTypeHeaderName) {
                contentTypeHeaderName = Client._contentType;
                init.headers[contentTypeHeaderName] = Client._jsonContentType;
            }

            const contentType = init.headers[contentTypeHeaderName];

            // Assign a new encoded body
            if (contentType.includes(Client._jsonContentType)) {
                if ((init.method === 'GET' || init.method === 'HEAD') && !!init.body) {
                    // oddly setting body to null still result in TypeError in phantomjs
                    init.body = undefined;
                } else {
                    init.body = JSON.stringify(init.body);
                }
            } else if (contentType.includes(Client._urlencodedContentType)) {
                init.body = objectToUrlParams(init.body);
            }
        }

        // Create a request with encoded body
        const req = new this._externals.Request(init.url, init);

        // Keep the original body accessible directly (for mocks)
        req.originalBody = init.body;

        return req;
    }

    public _isContentType(contentType, response) {
        return this.getContentType(response).includes(contentType);
    }

    public getContentType(response) {
        return response.headers.get(Client._contentType) || '';
    }

    public isMultipart(response) {
        return this._isContentType(Client._multipartContentType, response);
    }

    public isJson(response) {
        return this._isContentType(Client._jsonContentType, response);
    }

    public async toMultipart(response: Response): Promise<Response[]> {
        return this.isMultipart(response) ? this.multipart(response) : [response];
    }

    public async multipart(response: Response): Promise<Response[]> {
        if (!this.isMultipart(response)) {
            throw new Error('Response is not multipart');
        }

        // Step 1. Split multipart response

        const text = await response.text();

        if (!text) {
            throw new Error('No response body');
        }

        let boundary;

        try {
            boundary = this.getContentType(response).match(/boundary=([^;]+)/i)[1]; //eslint-disable-line
        } catch (e) {
            throw new Error('Cannot find boundary');
        }

        if (!boundary) {
            throw new Error('Cannot find boundary');
        }

        const parts = text.toString().split(Client._boundarySeparator + boundary);

        if (parts[0].trim() === '') {
            parts.shift();
        }
        if (parts[parts.length - 1].trim() === Client._boundarySeparator) {
            parts.pop();
        }

        if (parts.length < 1) {
            throw new Error('No parts in body');
        }

        // Step 2. Parse status info

        const statusInfo = await this._create(parts.shift(), response.status, response.statusText).json();

        // Step 3. Parse all other parts

        return parts.map((part, i) => this._create(part, statusInfo.response[i].status));
    }

    /**
     * Method is used to create Response object from string parts of multipart/mixed response
     */
    private _create(text = '', status = 200, statusText = 'OK'): Response {
        text = text.replace(/\r/g, '');

        const headers = new this._externals.Headers();
        const headersAndBody = text.split(Client._bodySeparator);
        const headersText = headersAndBody.length > 1 ? headersAndBody.shift() : '';

        text = headersAndBody.length > 0 ? headersAndBody.join(Client._bodySeparator) : null;

        (headersText || '').split('\n').forEach((header) => {
            const split = header.trim().split(Client._headerSeparator);
            const key = split.shift().trim();
            const value = split.join(Client._headerSeparator).trim();

            if (key) {
                headers.append(key, value);
            }
        });

        return new this._externals.Response(text, {
            headers,
            status,
            statusText,
        });
    }

    public async error(response: Response, skipOKCheck = false): Promise<string> {
        if (response.ok && !skipOKCheck) {
            return null;
        }

        let msg = (response.status ? `${response.status} ` : '') + (response.statusText ? response.statusText : '');

        try {
            const {message, error_description, description} = await response.clone().json();

            if (message) {
                msg = message;
            }
            if (error_description) {
                msg = error_description;
            }
            if (description) {
                msg = description;
            }
        } catch (e) {} //eslint-disable-line

        return msg;
    }

    public on(event: events.beforeRequest, listener: (request: Request) => void);
    public on(event: events.requestSuccess, listener: (response: Response, request: Request) => void);
    public on(event: events.requestError, listener: (error: ApiError) => void);
    public on(event: string, listener: (...args) => void) {
        return super.on(event, listener);
    }
}

export interface CreateRequestOptions extends RequestInit {
    url?: string;
    body?: any;
    query?: any;
    headers?: any;
}

1	import {EventEmitter} from 'events';	4✔
2	import isPlainObject from 'is-plain-object';	4✔
3
4	import Externals from '../core/Externals';
5	import {objectToUrlParams} from './utils';	4✔
6
7	function findHeaderName(name, headers) {
8	name = name.toLowerCase();	213✔
9	return Object.keys(headers).reduce((res, key) => {	213✔
10	if (res) {	219✔
11	return res;	104✔
12	}
13	if (name === key.toLowerCase()) {	115✔
14	return key;	114✔
15	}
16	return res;	1✔
17	}, null);
18	}
19
20	export interface ApiError extends Error {
21	originalMessage?: string;
22	response?: Response;
23	request?: Request;
24	}
25
26	export interface ClientOptions {
27	externals: Externals;
28	defaultRequestInit: CreateRequestOptions;
29	}
30
31	export enum events {	4✔
32	beforeRequest = 'beforeRequest',	4✔
33	requestSuccess = 'requestSuccess',	4✔
34	requestError = 'requestError',	4✔
35	}
36
37	export default class Client extends EventEmitter {	4✔
38	public static _contentType = 'Content-Type';	4✔
39
40	public static _jsonContentType = 'application/json';	4✔
41
42	public static _multipartContentType = 'multipart/mixed';	4✔
43
44	public static _urlencodedContentType = 'application/x-www-form-urlencoded';	4✔
45
46	public static _headerSeparator = ':';	4✔
47
48	public static _bodySeparator = '\n\n';	4✔
49
50	public static _boundarySeparator = '--';	4✔
51
52	public static _unauthorizedStatus = 401;	4✔
53
54	public static _rateLimitStatus = 429;	4✔
55
56	public static _allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];	4✔
57
58	public static _defaultRequestInit: CreateRequestOptions = {	4✔
59	credentials: 'include',
60	mode: 'cors',
61	};
62
63	public events = events;	97✔
64
65	private _externals: Externals;
66
67	private _defaultRequestInit: CreateRequestOptions = {};	97✔
68
69	public constructor({externals, defaultRequestInit = {}}: ClientOptions) {	97!
70	super();	97✔
71	this._defaultRequestInit = defaultRequestInit;	97✔
72	this._externals = externals;	97✔
73	}
74
75	/**
76	* Send a request and handle the response asynchronously.
77	* @param {Request} request - The request to send.
78	* @returns {Promise<Response>} - A promise resolving to the response.
79	*/
80	public async sendRequest(request: Request): Promise<Response> {	4✔
81	let response;
82	try {
83	//TODO Stop request if listeners return false
84	this.emit(this.events.beforeRequest, request);	210✔
85
86	response = await this._loadResponse(request);	210✔
87
88	if (!response.ok) {	210✔
89	throw new Error('Response has unsuccessful status');	28✔
90	}
91
92	this.emit(this.events.requestSuccess, response, request);	182✔
93
94	return response;	182✔
95	} catch (e) {
96	const error = !e.response ? await this.makeError(e, response, request) : e;	56!
97
98	this.emit(this.events.requestError, error);	28✔
99
100	throw error;	28✔
101	}
102	}
103
104	public async _loadResponse(request: Request): Promise<Response> {	4✔
105	return this._externals.fetch.call(null, request); // fixed illegal invocation in Chrome	210✔
106	}
107
108	/**
109	* Wraps the JS Error object with transaction information
110	*/
111	public async makeError(e: any, response: Response = null, request: Request = null): Promise<ApiError> {	30!
112	// Wrap only if regular error
113	if (!e.response && !e.originalMessage) {	29!
114	e.response = response;	29✔
115	e.request = request;	29✔
116	e.originalMessage = e.message;	29✔
117	e.message = (response && (await this.error(response, true))) \|\| e.originalMessage;	29!
118	}
119
120	return e;	29✔
121	}
122
123	public createRequest(init: CreateRequestOptions = Client._defaultRequestInit): Request {	214!
124	init = {...this._defaultRequestInit, ...init};	214✔
125	init.headers = init.headers \|\| {};	214✔
126
127	// Sanity checks
128	if (!init.url) {	214!
NEW 129	throw new Error('Url is not defined');	×
130	}
131	if (!init.method) {	214✔
132	init.method = 'GET';	1✔
133	}
134	init.method = init.method.toUpperCase();	214✔
135	if (init.method && Client._allowedMethods.indexOf(init.method) < 0) {	214✔
136	throw new Error(`Method has wrong value: ${init.method}`);	1✔
137	}
138
139	// Defaults
140	init.credentials = init.credentials \|\| 'include';	213✔
141	init.mode = init.mode \|\| 'cors';	213✔
142
143	// Append Query String
144	if (init.query) {	213✔
145	init.url = init.url + (init.url.includes('?') ? '&' : '?') + objectToUrlParams(init.query);	27!
146	}
147	// Serialize body
148	if (isPlainObject(init.body) \|\| !init.body) {	213✔
149	let contentTypeHeaderName = findHeaderName(Client._contentType, init.headers);	213✔
150
151	if (!contentTypeHeaderName) {	213✔
152	contentTypeHeaderName = Client._contentType;	99✔
153	init.headers[contentTypeHeaderName] = Client._jsonContentType;	99✔
154	}
155
156	const contentType = init.headers[contentTypeHeaderName];	213✔
157
158	// Assign a new encoded body
159	if (contentType.includes(Client._jsonContentType)) {	213✔
160	if ((init.method === 'GET' \|\| init.method === 'HEAD') && !!init.body) {	99!
161	// oddly setting body to null still result in TypeError in phantomjs
162	init.body = undefined;	×
163	} else {
164	init.body = JSON.stringify(init.body);	99✔
165	}
166	} else if (contentType.includes(Client._urlencodedContentType)) {	114✔
167	init.body = objectToUrlParams(init.body);	114✔
168	}
169	}
170
171	// Create a request with encoded body
172	const req = new this._externals.Request(init.url, init);	213✔
173
174	// Keep the original body accessible directly (for mocks)
175	req.originalBody = init.body;	213✔
176
177	return req;	213✔
178	}
179
180	public _isContentType(contentType, response) {	4✔
181	return this.getContentType(response).includes(contentType);	9✔
182	}
183
184	public getContentType(response) {	4✔
185	return response.headers.get(Client._contentType) \|\| '';	13!
186	}
187
188	public isMultipart(response) {	4✔
189	return this._isContentType(Client._multipartContentType, response);	8✔
190	}
191
192	public isJson(response) {	4✔
193	return this._isContentType(Client._jsonContentType, response);	1✔
194	}
195
196	public async toMultipart(response: Response): Promise<Response[]> {	4✔
197	return this.isMultipart(response) ? this.multipart(response) : [response];	1!
198	}
199
200	public async multipart(response: Response): Promise<Response[]> {	4✔
201	if (!this.isMultipart(response)) {	6✔
202	throw new Error('Response is not multipart');	1✔
203	}
204
205	// Step 1. Split multipart response
206
207	const text = await response.text();	5✔
208
209	if (!text) {	5✔
210	throw new Error('No response body');	1✔
211	}
212
213	let boundary;
214
215	try {	4✔
216	boundary = this.getContentType(response).match(/boundary=([^;]+)/i)[1]; //eslint-disable-line	4✔
217	} catch (e) {
218	throw new Error('Cannot find boundary');	1✔
219	}
220
221	if (!boundary) {	3!
NEW 222	throw new Error('Cannot find boundary');	×
223	}
224
225	const parts = text.toString().split(Client._boundarySeparator + boundary);	3✔
226
227	if (parts[0].trim() === '') {	3✔
228	parts.shift();	3✔
229	}
230	if (parts[parts.length - 1].trim() === Client._boundarySeparator) {	3✔
231	parts.pop();	3✔
232	}
233
234	if (parts.length < 1) {	3!
NEW 235	throw new Error('No parts in body');	×
236	}
237
238	// Step 2. Parse status info
239
240	const statusInfo = await this._create(parts.shift(), response.status, response.statusText).json();	3✔
241
242	// Step 3. Parse all other parts
243
244	return parts.map((part, i) => this._create(part, statusInfo.response[i].status));	5✔
245	}
246
247	/**
248	* Method is used to create Response object from string parts of multipart/mixed response
249	*/
250	private _create(text = '', status = 200, statusText = 'OK'): Response {	13!
251	text = text.replace(/\r/g, '');	8✔
252
253	const headers = new this._externals.Headers();	8✔
254	const headersAndBody = text.split(Client._bodySeparator);	8✔
255	const headersText = headersAndBody.length > 1 ? headersAndBody.shift() : '';	8!
256
257	text = headersAndBody.length > 0 ? headersAndBody.join(Client._bodySeparator) : null;	8!
258
259	(headersText \|\| '').split('\n').forEach((header) => {	8!
260	const split = header.trim().split(Client._headerSeparator);	16✔
261	const key = split.shift().trim();	16✔
262	const value = split.join(Client._headerSeparator).trim();	16✔
263
264	if (key) {	16✔
265	headers.append(key, value);	8✔
266	}
267	});
268
269	return new this._externals.Response(text, {	8✔
270	headers,
271	status,
272	statusText,
273	});
274	}
275
276	public async error(response: Response, skipOKCheck = false): Promise<string> {	31✔
277	if (response.ok && !skipOKCheck) {	30!
NEW 278	return null;	×
279	}
280
281	let msg = (response.status ? `${response.status} ` : '') + (response.statusText ? response.statusText : '');	30!
282
283	try {
284	const {message, error_description, description} = await response.clone().json();	30✔
285
286	if (message) {	24✔
287	msg = message;	10✔
288	}
289	if (error_description) {	24✔
290	msg = error_description;	4✔
291	}
292	if (description) {	24✔
293	msg = description;	14✔
294	}
295	} catch (e) {} //eslint-disable-line	30✔
296
297	return msg;	30✔
298	}
299
300	public on(event: events.beforeRequest, listener: (request: Request) => void);
301	public on(event: events.requestSuccess, listener: (response: Response, request: Request) => void);
302	public on(event: events.requestError, listener: (error: ApiError) => void);
303	public on(event: string, listener: (...args) => void) {	4✔
304	return super.on(event, listener);	40✔
305	}
306	}	4✔
307
308	export interface CreateRequestOptions extends RequestInit {
309	url?: string;
310	body?: any;
311	query?: any;
312	headers?: any;
313	}

ringcentral / ringcentral-js / 8795033128

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