smartystreets-javascript-sdk 1.13.7 → 2.1.0

package/Makefile

@@ -1,6 +1,6 @@
 #!/usr/bin/make -f
 
-VERSION           := $(shell tagit -p --dry-run)
+VERSION           := $(shell tagit -m --dry-run)
 VERSION_FILE1     := package.json
 VERSION_FILE2     := package-lock.json
 
@@ -11,7 +11,7 @@ node_modules:
 	npm install
 
 publish: test version upload unversion
-	tagit -p
+	tagit -m
 	git push origin --tags
 
 upload:

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "smartystreets-javascript-sdk",
- "version": "1.13.7",
+ "version": "2.1.0",
  "description": "Quick and easy Smarty address validation.",
  "keywords": [
   "smarty",
@@ -32,8 +32,8 @@
   "url": "github:smartystreets/smartystreets-javascript-sdk"
  },
  "devDependencies": {
-  "chai": "^4.2.0",
-  "mocha": "^9.2.1"
+  "chai": "^4.3.6",
+  "mocha": "^9.2.2"
  },
  "dependencies": {
   "axios": "^0.26.1",

package/src/ClientBuilder.js

@@ -8,6 +8,8 @@ const CustomHeaderSender = require("./CustomHeaderSender");
 const StatusCodeSender = require("./StatusCodeSender");
 const LicenseSender = require("./LicenseSender");
 const BadCredentialsError = require("./Errors").BadCredentialsError;
+const RetrySender = require("./RetrySender.js");
+const Sleeper = require("./util/Sleeper.js");
 
 //TODO: refactor this to work more cleanly with a bundler.
 const UsStreetClient = require("./us_street/Client");
@@ -151,10 +153,14 @@ class ClientBuilder {
 	buildSender() {
 		if (this.httpSender) return this.httpSender;
 
-		const httpSender = new HttpSender(this.maxTimeout, this.maxRetries, this.proxy, this.debug);
+		const httpSender = new HttpSender(this.maxTimeout, this.proxy, this.debug);
 		const statusCodeSender = new StatusCodeSender(httpSender);
 		const signingSender = new SigningSender(statusCodeSender, this.signer);
-		const agentSender = new AgentSender(signingSender);
+		let agentSender = new AgentSender(signingSender);
+		if (this.maxRetries > 0) {
+			const retrySender = new RetrySender(this.maxRetries, signingSender, new Sleeper());
+			agentSender = new AgentSender(retrySender);
+		}
 		const customHeaderSender = new CustomHeaderSender(agentSender, this.customHeaders);
 		const baseUrlSender = new BaseUrlSender(customHeaderSender, this.baseUrl);
 		const licenseSender = new LicenseSender(baseUrlSender, this.licenses);

package/src/HttpSender.js

@@ -1,12 +1,9 @@
 const Response = require("./Response");
 const Axios = require("axios");
-const axiosRetry = require("axios-retry");
+const {buildSmartyResponse} = require("../src/util/buildSmartyResponse");
 
 class HttpSender {
-	constructor(timeout = 10000, retries = 5, proxyConfig, debug = false) {
-		axiosRetry(Axios, {
-			retries: retries,
-		});
+	constructor(timeout = 10000, proxyConfig, debug = false) {
 		this.timeout = timeout;
 		this.proxyConfig = proxyConfig;
 		if (debug) this.enableDebug();
@@ -33,24 +30,19 @@ class HttpSender {
 		return config;
 	}
 
-	buildSmartyResponse(response, error) {
-		if (response) return new Response(response.status, response.data);
-		return new Response(undefined, undefined, error)
-	}
-
 	send(request) {
 		return new Promise((resolve, reject) => {
 			let requestConfig = this.buildRequestConfig(request);
 
 			Axios(requestConfig)
 				.then(response => {
-					let smartyResponse = this.buildSmartyResponse(response);
+					let smartyResponse = buildSmartyResponse(response);
 
 					if (smartyResponse.statusCode >= 400) reject(smartyResponse);
 
 					resolve(smartyResponse);
 				})
-				.catch(error => reject(this.buildSmartyResponse(undefined, error)));
+				.catch(error => reject(buildSmartyResponse(undefined, error)));
 		});
 	}
 

package/src/Response.js

@@ -1,8 +1,9 @@
 class Response {
-	constructor (statusCode, payload, error = undefined) {
+	constructor (statusCode, payload, error, headers) {
 		this.statusCode = statusCode;
 		this.payload = payload;
 		this.error = error;
+		this.headers = headers;
 	}
 }
 

package/src/RetrySender.js

@@ -0,0 +1,50 @@
+class RetrySender {
+	constructor(maxRetires = 5, inner, sleeper) {
+		this.maxRetries = maxRetires;
+		this.statusToRetry = [408, 429, 500, 502, 503, 504];
+		this.statusTooManyRequests = 429;
+		this.maxBackoffDuration = 10;
+		this.inner = inner;
+		this.sleeper = sleeper;
+	}
+
+	async send(request) {
+		let response = await this.inner.send(request);
+
+		for (let i = 0; i < this.maxRetries; i++) {
+
+			if (!this.statusToRetry.includes(parseInt(response.statusCode))) {
+				break;
+			}
+
+			if (parseInt(response.statusCode) === this.statusTooManyRequests) {
+				let secondsToBackoff = 10;
+				if (response.headers) {
+					const retryAfterHeader = response.headers["Retry-After"];
+					if (Number.isInteger(retryAfterHeader)) {
+						secondsToBackoff = retryAfterHeader;
+					}
+				}
+				await this.rateLimitBackOff(secondsToBackoff);
+			} else {
+				await this.backoff(i);
+			}
+			response = await this.inner.send(request);
+		}
+
+		return response;
+	};
+
+	async backoff(attempt) {
+		const backoffDuration = Math.min(attempt, this.maxBackoffDuration);
+		console.log(`There was an error processing the request. Retrying in ${backoffDuration} seconds...`);
+		await this.sleeper.sleep(backoffDuration);
+	};
+
+	async rateLimitBackOff(backoffDuration) {
+		console.log(`Rate limit reached. Retrying in ${backoffDuration} seconds...`);
+		await this.sleeper.sleep(backoffDuration);
+	};
+}
+
+module.exports = RetrySender;

package/src/international_street/Candidate.js

@@ -25,6 +25,8 @@ class Candidate {
 			this.components.countryIso3 = responseData.components.country_iso_3;
 			this.components.superAdministrativeArea = responseData.components.super_administrative_area;
 			this.components.administrativeArea = responseData.components.administrative_area;
+			this.components.administrativeAreaShort = responseData.components.administrative_area_short;
+			this.components.administrativeAreaLong = responseData.components.administrative_area_long;
 			this.components.subAdministrativeArea = responseData.components.sub_administrative_area;
 			this.components.dependentLocality = responseData.components.dependent_locality;
 			this.components.dependentLocalityName = responseData.components.dependent_locality_name;
@@ -58,6 +60,8 @@ class Candidate {
 			this.components.subBuildingNumber = responseData.components.sub_building_number;
 			this.components.subBuildingName = responseData.components.sub_building_name;
 			this.components.subBuilding = responseData.components.sub_building;
+			this.components.levelType = responseData.components.level_type;
+			this.components.levelNumber = responseData.components.level_number;
 			this.components.postBox = responseData.components.post_box;
 			this.components.postBoxType = responseData.components.post_box_type;
 			this.components.postBoxNumber = responseData.components.post_box_number;
@@ -90,6 +94,8 @@ class Candidate {
 					this.analysis.changes.components.countryIso3 = responseData.analysis.changes.components.country_iso_3;
 					this.analysis.changes.components.superAdministrativeArea = responseData.analysis.changes.components.super_administrative_area;
 					this.analysis.changes.components.administrativeArea = responseData.analysis.changes.components.administrative_area;
+					this.analysis.changes.components.administrativeAreaShort = responseData.analysis.changes.components.administrative_area_short;
+					this.analysis.changes.components.administrativeAreaLong = responseData.analysis.changes.components.administrative_area_long;
 					this.analysis.changes.components.subAdministrativeArea = responseData.analysis.changes.components.sub_administrative_area;
 					this.analysis.changes.components.dependentLocality = responseData.analysis.changes.components.dependent_locality;
 					this.analysis.changes.components.dependentLocalityName = responseData.analysis.changes.components.dependent_locality_name;
@@ -123,6 +129,8 @@ class Candidate {
 					this.analysis.changes.components.subBuildingNumber = responseData.analysis.changes.components.sub_building_number;
 					this.analysis.changes.components.subBuildingName = responseData.analysis.changes.components.sub_building_name;
 					this.analysis.changes.components.subBuilding = responseData.analysis.changes.components.sub_building;
+					this.analysis.changes.components.levelType = responseData.analysis.changes.components.level_type;
+					this.analysis.changes.components.levelNumber = responseData.analysis.changes.components.level_number;
 					this.analysis.changes.components.postBox = responseData.analysis.changes.components.post_box;
 					this.analysis.changes.components.postBoxType = responseData.analysis.changes.components.post_box_type;
 					this.analysis.changes.components.postBoxNumber = responseData.analysis.changes.components.post_box_number;

package/src/util/Sleeper.js

@@ -0,0 +1,8 @@
+class Sleeper {
+	constructor () {}
+	sleep(seconds) {
+		return new Promise(resolve => setTimeout(resolve, seconds*1000));
+	}
+}
+
+module.exports = Sleeper;

package/src/util/buildSmartyResponse.js

@@ -0,0 +1,10 @@
+const Response = require("../Response.js");
+
+function buildSmartyResponse(response, error) {
+	if (response) return new Response(response.status, response.data, response.error, response.headers);
+	return new Response(undefined, undefined, error)
+}
+
+module.exports = {
+	buildSmartyResponse
+};

package/tests/fixtures/MockSleeper.js

@@ -0,0 +1,10 @@
+class MockSleeper {
+	constructor() {
+		this.sleepDurations = [];
+	}
+	sleep(ms) {
+		this.sleepDurations.push(ms);
+	}
+}
+
+module.exports = MockSleeper;

package/tests/fixtures/mock_senders.js

@@ -1,3 +1,4 @@
+const {buildSmartyResponse} = require("../../src/util/buildSmartyResponse.js");
 const Response = require("../../src/Response");
 
 module.exports = {
@@ -20,4 +21,21 @@ module.exports = {
 			});
 		}
 	},
-};
+	MockSenderWithStatusCodesAndHeaders: function (statusCodes, headers = undefined, error = undefined) {
+		this.statusCodes = statusCodes;
+		this.headers = headers;
+		this.error = error;
+		this.currentStatusCodeIndex = 0;
+
+		this.send = function (request) {
+			let mockResponse = {
+				status: this.statusCodes[this.currentStatusCodeIndex],
+				headers: this.headers,
+				error: this.error,
+			};
+			const response = buildSmartyResponse(mockResponse);
+			this.currentStatusCodeIndex += 1;
+			return response;
+		}
+	}
+};

package/tests/international_street/test_Candidate.js

@@ -22,6 +22,8 @@ describe("An International match candidate", function () {
 				country_iso_3: "14",
 				super_administrative_area: "15",
 				administrative_area: "16",
+				administrative_area_short: "16.1",
+				administrative_area_long: "16.2",
 				sub_administrative_area: "17",
 				dependent_locality: "18",
 				dependent_locality_name: "19",
@@ -55,6 +57,8 @@ describe("An International match candidate", function () {
 				sub_building_number: "46",
 				sub_building_name: "47",
 				sub_building: "48",
+				level_type: "48.1",
+				level_number: "48.2",
 				post_box: "49",
 				post_box_type: "50",
 				post_box_number: "51",
@@ -88,6 +92,8 @@ describe("An International match candidate", function () {
 						country_iso_3: "73",
 						super_administrative_area: "74",
 						administrative_area: "75",
+						administrative_area_short: "75.1",
+						administrative_area_long: "75.2",
 						sub_administrative_area: "76",
 						dependent_locality: "77",
 						dependent_locality_name: "78",
@@ -121,6 +127,8 @@ describe("An International match candidate", function () {
 						sub_building_number: "106",
 						sub_building_name: "107",
 						sub_building: "108",
+						level_type: "108.1",
+						level_number: "108.2",
 						post_box: "109",
 						post_box_type: "110",
 						post_box_number: "111",
@@ -148,6 +156,8 @@ describe("An International match candidate", function () {
 		expect(components.countryIso3).to.equal("14");
 		expect(components.superAdministrativeArea).to.equal("15");
 		expect(components.administrativeArea).to.equal("16");
+		expect(components.administrativeAreaShort).to.equal("16.1");
+		expect(components.administrativeAreaLong).to.equal("16.2");
 		expect(components.subAdministrativeArea).to.equal("17");
 		expect(components.dependentLocality).to.equal("18");
 		expect(components.dependentLocalityName).to.equal("19");
@@ -181,6 +191,8 @@ describe("An International match candidate", function () {
 		expect(components.subBuildingNumber).to.equal("46");
 		expect(components.subBuildingName).to.equal("47");
 		expect(components.subBuilding).to.equal("48");
+		expect(components.levelType).to.equal("48.1");
+		expect(components.levelNumber).to.equal("48.2");
 		expect(components.postBox).to.equal("49");
 		expect(components.postBoxType).to.equal("50");
 		expect(components.postBoxNumber).to.equal("51");
@@ -212,6 +224,8 @@ describe("An International match candidate", function () {
 		expect(ccomponents.countryIso3).to.equal("73");
 		expect(ccomponents.superAdministrativeArea).to.equal("74");
 		expect(ccomponents.administrativeArea).to.equal("75");
+		expect(ccomponents.administrativeAreaShort).to.equal("75.1");
+		expect(ccomponents.administrativeAreaLong).to.equal("75.2");
 		expect(ccomponents.subAdministrativeArea).to.equal("76");
 		expect(ccomponents.dependentLocality).to.equal("77");
 		expect(ccomponents.dependentLocalityName).to.equal("78");
@@ -245,6 +259,8 @@ describe("An International match candidate", function () {
 		expect(ccomponents.subBuildingNumber).to.equal("106");
 		expect(ccomponents.subBuildingName).to.equal("107");
 		expect(ccomponents.subBuilding).to.equal("108");
+		expect(ccomponents.levelType).to.equal("108.1");
+		expect(ccomponents.levelNumber).to.equal("108.2");
 		expect(ccomponents.postBox).to.equal("109");
 		expect(ccomponents.postBoxType).to.equal("110");
 		expect(ccomponents.postBoxNumber).to.equal("111");

package/tests/test_HttpSender.js

@@ -2,6 +2,7 @@ const chai = require("chai");
 const expect = chai.expect;
 const Request = require("../src/Request");
 const HttpSender = require("../src/HttpSender");
+const {buildSmartyResponse} = require("../src/util/buildSmartyResponse");
 
 describe ("An Axios implementation of a HTTP sender", function () {
 	it("adds a data payload to the HTTP request config.", function () {
@@ -71,7 +72,7 @@ describe ("An Axios implementation of a HTTP sender", function () {
 		let mockResponse = {
 			status: 200
 		};
-		let smartyResponse = sender.buildSmartyResponse(mockResponse);
+		let smartyResponse = buildSmartyResponse(mockResponse);
 
 		expect(smartyResponse.hasOwnProperty("statusCode")).to.equal(true);
 		expect(smartyResponse.statusCode).to.equal(200);
@@ -84,7 +85,7 @@ describe ("An Axios implementation of a HTTP sender", function () {
 			status: 200,
 			data: mockData
 		};
-		let smartyResponse = sender.buildSmartyResponse(mockResponse);
+		let smartyResponse = buildSmartyResponse(mockResponse);
 
 		expect(smartyResponse.hasOwnProperty("payload")).to.equal(true);
 		expect(smartyResponse.payload).to.equal(mockData);

package/tests/test_RetrySender.js

@@ -0,0 +1,98 @@
+const chai = require("chai");
+const expect = chai.expect;
+const RetrySender = require("../src/RetrySender");
+const {MockSenderWithStatusCodesAndHeaders} = require("./fixtures/mock_senders");
+const Request = require("../src/Request.js");
+const MockSleeper = require("./fixtures/MockSleeper.js");
+
+async function sendWithRetry(retries, inner, sleeper) {
+	const request = new Request();
+	const sender = new RetrySender(retries, inner, sleeper);
+	return await sender.send(request);
+}
+
+describe ("Retry Sender tests", function () {
+	it("test success does not retry", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["200"]);
+		await sendWithRetry(5, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(1);
+	});
+
+	it("test client error does not retry", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["422"]);
+		await sendWithRetry(5, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(1);
+	});
+
+	it("test will retry until success", async function () {
+		let inner =  new MockSenderWithStatusCodesAndHeaders(["500", "500", "500", "200", "500"]);
+		await sendWithRetry(10, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(4);
+	});
+
+	it("test return response if retry limit exceeded", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["500", "500", "500", "500", "500"]);
+		const sleeper = new MockSleeper();
+		const response = await sendWithRetry(4, inner, sleeper);
+
+		expect(response);
+		expect(inner.currentStatusCodeIndex).to.equal(5);
+		expect(response.statusCode).to.equal("500");
+		expect(sleeper.sleepDurations).to.deep.equal([0, 1, 2, 3]);
+	});
+
+	it("test backoff does not exceed max", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "200"]);
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(20, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([0,1,2,3,4,5,6,7,8,9,10,10,10]);
+	});
+
+	it("test empty status does not retry", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders([]);
+		await sendWithRetry(5, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(1);
+	});
+
+	it("test sleep on rate limit", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429", "200"]);
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(5, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([10]);
+	});
+
+	it("test rate limit error return", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429"], {"Retry-After": 7});
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(10, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([7]);
+	});
+
+	it("test retry after invalid value", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429"], {"Retry-After": "a"});
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(10, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([10]);
+	});
+
+	it("test retry error", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429"], undefined, "Big Bad");
+		const sleeper = new MockSleeper();
+
+		const response = await sendWithRetry(10, inner, sleeper);
+
+		expect(response.error).to.equal("Big Bad");
+	});
+});