reshuffle-fastspring-connector
Version:
Reshuffle connectors for FastSpring
288 lines • 14.1 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
exports.__esModule = true;
exports.FastSpringConnector = void 0;
var node_fetch_1 = __importDefault(require("node-fetch"));
var reshuffle_base_connector_1 = require("reshuffle-base-connector");
function validateUsername(username) {
if (typeof username !== 'string' || username.length === 0) {
throw new Error("Invalid username: " + username);
}
return username;
}
function validatePassword(password) {
if (typeof password !== 'string' || password.length === 0) {
throw new Error("Invalid password: " + password);
}
return password;
}
function validateProductID(productID) {
if (!/^[a-z0-9-]{2,}$/.test(productID)) {
throw new Error("Invalid product ID: " + productID);
}
return productID;
}
var FastSpringError = /** @class */ (function (_super) {
__extends(FastSpringError, _super);
function FastSpringError(code, status, reason) {
var _this = _super.call(this, "FastSpring API Error: " + code + " " + status) || this;
_this.code = code;
_this.status = status;
_this.reason = reason;
return _this;
}
return FastSpringError;
}(Error));
var FastSpringConnector = /** @class */ (function (_super) {
__extends(FastSpringConnector, _super);
function FastSpringConnector(app, options, id) {
var _this = _super.call(this, app, options, id) || this;
var un = validateUsername(options.username);
var pw = validatePassword(options.password);
_this.auth = "Basic " + Buffer.from(un + ":" + pw).toString('base64');
return _this;
}
FastSpringConnector.prototype.request = function (method, path, body) {
return __awaiter(this, void 0, void 0, function () {
var opts, res, _a, _b;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
opts = {
method: method,
headers: { Authorization: this.auth }
};
if (body) {
opts.body = JSON.stringify(body);
opts.headers['Content-Type'] = 'application/json';
}
return [4 /*yield*/, node_fetch_1["default"]("https://api.fastspring.com/" + path, opts)];
case 1:
res = _c.sent();
if (!(res.status < 200 || 300 <= res.status)) return [3 /*break*/, 3];
_a = FastSpringError.bind;
_b = [void 0, String(res.status),
res.statusText];
return [4 /*yield*/, res.text()];
case 2: throw new (_a.apply(FastSpringError, _b.concat([_c.sent()])))();
case 3: return [2 /*return*/, res.json()];
}
});
});
};
// Actions ////////////////////////////////////////////////////////
FastSpringConnector.prototype.deleteProduct = function (productID) {
return __awaiter(this, void 0, void 0, function () {
var res, product;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
validateProductID(productID);
return [4 /*yield*/, this.DELETE("products/" + productID)];
case 1:
res = _a.sent();
product = res.products[0];
if (product.result === 'error') {
throw new Error("Error deleting product " + productID + ": " + JSON.stringify(product.error));
}
return [2 /*return*/];
}
});
});
};
FastSpringConnector.prototype.getLocalizedPrice = function (productID, countryCode) {
return __awaiter(this, void 0, void 0, function () {
var country, res;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
validateProductID(productID);
if (countryCode !== undefined &&
(typeof countryCode !== 'string' || countryCode.length !== 2)) {
throw new Error("Invalid country code: " + countryCode);
}
country = countryCode ? "?country=" + countryCode : '';
return [4 /*yield*/, this.GET("products/price/" + productID + country)];
case 1:
res = _a.sent();
if (res.result === 'error') {
throw new Error("Error getting price for product " + productID + ": " + JSON.stringify(res.error));
}
return [2 /*return*/, res.products[0].pricing];
}
});
});
};
FastSpringConnector.prototype.getProductInfo = function (productID) {
return __awaiter(this, void 0, void 0, function () {
var res, product;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
validateProductID(productID);
return [4 /*yield*/, this.GET("products/" + productID)];
case 1:
res = _a.sent();
product = res.products[0];
if (product.result === 'error') {
throw new Error("Error getting info for product " + productID + ": " + JSON.stringify(product.error));
}
return [2 /*return*/, product];
}
});
});
};
FastSpringConnector.prototype.getProductList = function () {
return __awaiter(this, void 0, void 0, function () {
var res;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.GET('products')];
case 1:
res = _a.sent();
if (res.result === 'error') {
throw new Error("Error listing products: " + JSON.stringify(res.error));
}
return [2 /*return*/, res.products];
}
});
});
};
FastSpringConnector.prototype.updateProduct = function (productID, info) {
return __awaiter(this, void 0, void 0, function () {
var res, product;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
validateProductID(productID);
if (info.product !== undefined && info.product !== productID) {
throw new Error("Product ID mismatch when creating product: " + productID + " " + info.product);
}
info.product = productID;
return [4 /*yield*/, this.POST('products', { products: [info] })];
case 1:
res = _a.sent();
product = res.products[0];
if (product.result === 'error') {
throw new Error("Error creating product " + productID + ": " + JSON.stringify(product.error));
}
return [2 /*return*/];
}
});
});
};
FastSpringConnector.prototype.updateProducts = function (products) {
return __awaiter(this, void 0, void 0, function () {
var _i, products_1, product, res, _a, _b, product;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
if (!Array.isArray(products)) {
throw new Error('Expected products array');
}
for (_i = 0, products_1 = products; _i < products_1.length; _i++) {
product = products_1[_i].product;
validateProductID(product);
}
return [4 /*yield*/, this.POST('products', { products: products })];
case 1:
res = _c.sent();
for (_a = 0, _b = res.products; _a < _b.length; _a++) {
product = _b[_a];
if (product.result === 'error') {
throw new Error("Error creating product " + product.product + ": " + JSON.stringify(product.error));
}
}
return [2 /*return*/];
}
});
});
};
FastSpringConnector.prototype.updateSimpleProduct = function (productID, englishDisplay, usd) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
validateProductID(productID);
if (typeof englishDisplay !== 'string' || englishDisplay.length === 0) {
throw new Error("Invalid display for product " + productID + ": " + englishDisplay);
}
if (typeof usd !== 'number' || usd < 0) {
throw new Error("Invalid USD price for product " + productID + ": " + usd);
}
return [4 /*yield*/, this.updateProduct(productID, {
display: { en: englishDisplay },
pricing: { price: { USD: usd } }
})];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
// REST ///////////////////////////////////////////////////////////
FastSpringConnector.prototype.DELETE = function (path) {
return this.request('DELETE', path);
};
FastSpringConnector.prototype.GET = function (path) {
return this.request('GET', path);
};
FastSpringConnector.prototype.POST = function (path, body) {
return this.request('POST', path, body);
};
return FastSpringConnector;
}(reshuffle_base_connector_1.BaseConnector));
exports.FastSpringConnector = FastSpringConnector;
//# sourceMappingURL=index.js.map