1072406932

Build Type

push

github

Committed by rkrauskopf

Commit Message

W.I.P.

Run Details

159 of 216 branches covered (73.61%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

3 existing lines in 2 files now uncovered.

304 of 344 relevant lines covered (88.37%)

7.64 hits per line

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

93.62

/src/client/index.ts

import { AbortController, getUserAgentString } from "../isomorphic.node";
import { NormalizedConfig } from "../config";
import { ShipEngineError, RateLimitExceededError } from "../errors";
import { handle400Errors } from "./handle-400-errors";

export async function get<TResult>(
  endpoint: string,
  config: NormalizedConfig
): Promise<TResult> {
  return await sendRequestWithRetry(endpoint, "GET", undefined, config);
}

export async function post<TParams, TResult>(
  endpoint: string,
  body: TParams,
  config: NormalizedConfig
): Promise<TResult> {
  return await sendRequestWithRetry(endpoint, "POST", body, config);
}

export async function put<TParams, TResult>(
  endpoint: string,
  body: TParams,
  config: NormalizedConfig
): Promise<TResult> {
  return await sendRequestWithRetry(endpoint, "PUT", body, config);
}

export async function destroy<TResult>(
  endpoint: string,
  config: NormalizedConfig
): Promise<TResult> {
  return await sendRequestWithRetry(endpoint, "DELETE", undefined, config);
}

async function sendRequestWithRetry<TParams, TResult>(
  endpoint: string,
  method: "GET" | "POST" | "PUT" | "DELETE",
  body: TParams | undefined,
  config: NormalizedConfig
  // @ts-expect-error TypeScript is confused by the return in the for loop
): Promise<TResult> {
  const urlWithPath = new URL(endpoint, config.baseURL.toString());

  // Retry up to N times
  for (let retry = 0; retry <= config.retries; retry++) {
    try {
      return await sendRequest(urlWithPath, method, body, config);
    } catch (error) {
      if (
        retry < config.retries &&
        error instanceof RateLimitExceededError &&
        error.retryAfter < config.timeout
      ) {
        // The request was blocked due to exceeding the rate limit.
        // So wait the specified amount of time and then retry.
        await wait(error.retryAfter);
      } else if (error.name === "AbortError") {
        // The request timed out
        throw new ShipEngineError(
          "system",
          "timeout",
          `The ShipEngine ${endpoint} API timed out.`
        );
      } else {
        // Re-throw errors that were thrown from within sendRequest
        throw error;
      }
    }
  }
}

async function sendRequest<TParams, TResult>(
  url: URL,
  method: "GET" | "POST" | "PUT" | "DELETE",
  body: TParams | undefined,
  config: NormalizedConfig
): Promise<TResult> {
  // Create an AbortController so we can cancel the request if it times out
  const controller = new AbortController();
  setTimeout(() => controller.abort(), config.timeout);

  const response = await fetch(url.toString(), {
    body: body ? JSON.stringify(body) : undefined,
    method: method,
    mode: "cors" as const,
    signal: controller.signal,
    headers: buildHeaders(config),
  });

  const responseBody = await response.json();

  if (response.status === 429) {
    throw new RateLimitExceededError(
      responseBody.request_id,
      "shipengine",
      Number(response.headers.get("Retry-After")) || 0
    );
  }

  if (response.status === 400) handle400Errors(responseBody);

  return responseBody;
}

/**
 * Waits for the specified duration (in milliseconds)
 */
async function wait(duration: number): Promise<void> {
  await new Promise((resolve) => setTimeout(resolve, duration));
}

const userAgent = getUserAgentString();

/**
 * Builds request headers
 */
const buildHeaders = (config: NormalizedConfig) => {
  return {
    Accept: "application/json",
    "Content-Type": "application/json",
    "API-Key": config.apiKey,
    "User-Agent": userAgent,
  };
};

1	import { AbortController, getUserAgentString } from "../isomorphic.node";	1✔
2	import { NormalizedConfig } from "../config";
3	import { ShipEngineError, RateLimitExceededError } from "../errors";	1✔
4	import { handle400Errors } from "./handle-400-errors";	1✔
5
6	export async function get<TResult>(	1✔
7	endpoint: string,
8	config: NormalizedConfig
9	): Promise<TResult> {
10	return await sendRequestWithRetry(endpoint, "GET", undefined, config);	3✔
11	}
12
13	export async function post<TParams, TResult>(	1✔
14	endpoint: string,
15	body: TParams,
16	config: NormalizedConfig
17	): Promise<TResult> {
18	return await sendRequestWithRetry(endpoint, "POST", body, config);	7✔
19	}
20
21	export async function put<TParams, TResult>(	1✔
22	endpoint: string,
23	body: TParams,
24	config: NormalizedConfig
25	): Promise<TResult> {
26	return await sendRequestWithRetry(endpoint, "PUT", body, config);	1✔
27	}
28
29	export async function destroy<TResult>(	1✔
30	endpoint: string,
31	config: NormalizedConfig
32	): Promise<TResult> {
UNCOV 33	return await sendRequestWithRetry(endpoint, "DELETE", undefined, config);	×
34	}
35
36	async function sendRequestWithRetry<TParams, TResult>(
37	endpoint: string,
38	method: "GET" \| "POST" \| "PUT" \| "DELETE",
39	body: TParams \| undefined,
40	config: NormalizedConfig
41	// @ts-expect-error TypeScript is confused by the return in the for loop
42	): Promise<TResult> {
43	const urlWithPath = new URL(endpoint, config.baseURL.toString());	11✔
44
45	// Retry up to N times
46	for (let retry = 0; retry <= config.retries; retry++) {	11✔
47	try {	12✔
48	return await sendRequest(urlWithPath, method, body, config);	12✔
49	} catch (error) {
50	if (	3✔
51	retry < config.retries &&	6✔
52	error instanceof RateLimitExceededError &&
53	error.retryAfter < config.timeout
54	) {
55	// The request was blocked due to exceeding the rate limit.
56	// So wait the specified amount of time and then retry.
57	await wait(error.retryAfter);	1✔
58	} else if (error.name === "AbortError") {	2!
59	// The request timed out
UNCOV 60	throw new ShipEngineError(	×
61	"system",
62	"timeout",
63	`The ShipEngine ${endpoint} API timed out.`
64	);
65	} else {
66	// Re-throw errors that were thrown from within sendRequest
67	throw error;	2✔
68	}
69	}
70	}
71	}
72
73	async function sendRequest<TParams, TResult>(
74	url: URL,
75	method: "GET" \| "POST" \| "PUT" \| "DELETE",
76	body: TParams \| undefined,
77	config: NormalizedConfig
78	): Promise<TResult> {
79	// Create an AbortController so we can cancel the request if it times out
80	const controller = new AbortController();	12✔
81	setTimeout(() => controller.abort(), config.timeout);	12✔
82
83	const response = await fetch(url.toString(), {	12✔
84	body: body ? JSON.stringify(body) : undefined,	12✔
85	method: method,
86	mode: "cors" as const,
87	signal: controller.signal,
88	headers: buildHeaders(config),
89	});
90
91	const responseBody = await response.json();	12✔
92
93	if (response.status === 429) {	12✔
94	throw new RateLimitExceededError(	2✔
95	responseBody.request_id,
96	"shipengine",
97	Number(response.headers.get("Retry-After")) \|\| 0	4✔
98	);
99	}
100
101	if (response.status === 400) handle400Errors(responseBody);	10✔
102
103	return responseBody;	9✔
104	}
105
106	/**
107	* Waits for the specified duration (in milliseconds)
108	*/
109	async function wait(duration: number): Promise<void> {
110	await new Promise((resolve) => setTimeout(resolve, duration));	1✔
111	}
112
113	const userAgent = getUserAgentString();	1✔
114
115	/**
116	* Builds request headers
117	*/
118	const buildHeaders = (config: NormalizedConfig) => {	1✔
119	return {	12✔
120	Accept: "application/json",
121	"Content-Type": "application/json",
122	"API-Key": config.apiKey,
123	"User-Agent": userAgent,
124	};
125	};

ShipEngine / shipengine-js / 1072406932

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