@mentaport/common
Version:
Mentaport API helper package.
336 lines (323 loc) • 11.9 kB
JavaScript
import axios from 'axios';
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter(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 StatusCode;
(function (StatusCode) {
StatusCode["ERR_BAD_REQUES"] = "ERR_BAD_REQUEST";
StatusCode["Unauthorized"] = "401";
StatusCode["Forbidden"] = "403";
StatusCode["TooManyRequests"] = "429";
StatusCode["InternalServerError"] = "500";
})(StatusCode || (StatusCode = {}));
class Base {
// constructor called in client side
constructor(apiKey) {
this._apiKey = apiKey;
this._baseUrl = "";
this._http = axios.create({});
}
/**
* Function to set the client environment
*
* @param {apiUrl} urlPath (optional)
*
* @returns {void}
*/
setClientSide(apiUrl) {
let headers = {};
this._baseUrl = apiUrl;
headers = Object.assign(headers, { "x-api-key": this._apiKey });
this._http = axios.create({
baseURL: this._baseUrl,
headers,
});
}
request(config) {
return __awaiter(this, void 0, void 0, function* () {
try {
try {
const response = yield this._http.request(config);
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const res = response.data;
return res;
}
catch (error) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
return yield this.handleError(error);
}
}
catch (error) {
return Promise.reject(error);
}
});
}
upload(config, baseurl) {
return __awaiter(this, void 0, void 0, function* () {
const headers = {
"x-api-key": this._apiKey,
};
try {
const http_stream = axios.create({
baseURL: baseurl || this._baseUrl,
headers,
});
const response = yield http_stream.request(config);
if (response.data == null || response.data == '') {
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const res = response.status;
return res;
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const res1 = response.data;
return res1;
}
catch (error) {
return Promise.reject(error);
}
});
}
// protected async uploadServer<T, R = AxiosResponse<T> >(url:string, params:URLSearchParams, blob:Blob, baseurl?:string): Promise<T> {
// console.log('UPDATED uploadServer')
// const headers = {
// "x-api-key": this._apiKey,
// };
// const baseURL = baseurl || this._baseUrl;
// const dataForm = new FormData();
// dataForm.append('content', blob);
// try {
// const urlComplete = `${baseURL}${url}?${params.toString()}`
// console.log('UPDATED urlComplete', urlComplete)
// const response = await fetch(urlComplete, {
// method: 'POST',
// headers: headers,
// body: dataForm,
// });
// if(response.ok) {
// const res = await response.json() as T;
// return res
// }
// console.log("errior", response)
// // if(response.data == null || response.data == ''){
// // // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
// // const res: T = response.status as T;
// // return res;
// // }
// // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
// const res1: T = response as T;
// return res1;
// } catch (error) {
// return Promise.reject(error);
// }
// }
// Handle global app errors
// We can handle generic app errors depending on the status code
handleError(error) {
var _a;
const { code } = error;
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
let message = error.message;
// let message = error.message;
let codeRes = Number(code);
switch (code) {
case StatusCode.ERR_BAD_REQUES: {
// Handle InternalServerError
message = "Bad Request";
codeRes = 400;
break;
}
case StatusCode.InternalServerError: {
// Handle InternalServerError
message = "Internal server error";
break;
}
case StatusCode.Forbidden: {
// Handle Forbidden
message = "Forbidden";
break;
}
case StatusCode.Unauthorized: {
// Handle Unauthorized
message = "Unauthorized";
break;
}
case StatusCode.TooManyRequests: {
// Handle TooManyRequests
message = "TooManyRequests";
break;
}
}
const err = {
status: false,
statusCode: codeRes,
message: message,
data: (_a = error.response) === null || _a === void 0 ? void 0 : _a.data
};
return Promise.reject(err);
}
}
/**
* Typescripy Mixing to combine classes: https://www.typescriptlang.org/docs/handbook/mixins.html
*
*/
function applyCombination(derivedCtor, baseCtors) {
baseCtors.forEach(baseCtor => {
Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
Object.create(null));
});
});
}
/**
* Functions to help unit conversions
* @param unit to converty
* @returns converted unit
*/
function convertMetersToMiles(meters) {
const milesPerMeter = 0.000621371;
const miles = meters * milesPerMeter;
return miles;
}
function convertMilesToMeters(miles) {
const metersPerMile = 1609.34;
const meters = miles * metersPerMile;
return meters;
}
//---------------
function convertMetersToFeet(meters) {
const feetPerMeter = 3.28084;
const feet = meters * feetPerMeter;
return feet;
}
function convertFeetToMeters(feet) {
const metersPerFoot = 0.3048;
const meters = feet * metersPerFoot;
return meters;
}
//---------------
function convertMetersToKilometers(meters) {
const kilometersPerMeter = 0.001;
const kilometers = meters * kilometersPerMeter;
return kilometers;
}
function convertKilometersToMeters(kilometers) {
const metersPerKilometer = 1000;
const meters = kilometers * metersPerKilometer;
return meters;
}
//---------------
function convertMilesToKilometers(miles) {
const kilometersPerMile = 1.609344;
const kilometers = miles * kilometersPerMile;
return kilometers;
}
function convertKilometersToMiles(kilometers) {
const milesPerKilometer = 0.621371;
const miles = kilometers * milesPerKilometer;
return miles;
}
//---------------
function metersToKilometers(meters) {
return meters * 0.001;
}
function kilometersToMeters(kilometers) {
return kilometers / 0.001;
}
var utils = /*#__PURE__*/Object.freeze({
__proto__: null,
convertMetersToMiles: convertMetersToMiles,
convertMilesToMeters: convertMilesToMeters,
convertMetersToFeet: convertMetersToFeet,
convertFeetToMeters: convertFeetToMeters,
convertMetersToKilometers: convertMetersToKilometers,
convertKilometersToMeters: convertKilometersToMeters,
convertMilesToKilometers: convertMilesToKilometers,
convertKilometersToMiles: convertKilometersToMiles,
metersToKilometers: metersToKilometers,
kilometersToMeters: kilometersToMeters
});
var ContractStatus;
(function (ContractStatus) {
ContractStatus["NonActive"] = "NonActive";
ContractStatus["Pending"] = "Pending";
ContractStatus["Active"] = "Active";
ContractStatus["Paused"] = "Paused";
ContractStatus["Archive"] = "Archive";
})(ContractStatus || (ContractStatus = {}));
var ContractEnvironment;
(function (ContractEnvironment) {
ContractEnvironment["Localhost"] = "localhost";
ContractEnvironment["Testnet"] = "testnet";
ContractEnvironment["Mainnet"] = "mainnet";
ContractEnvironment["Mezzanine"] = "mezzanine";
})(ContractEnvironment || (ContractEnvironment = {}));
var BlockchainTypes;
(function (BlockchainTypes) {
BlockchainTypes["Ethereum"] = "ethereum";
BlockchainTypes["Polygon"] = "polygon";
BlockchainTypes["Base"] = "base";
BlockchainTypes["Sui"] = "sui";
BlockchainTypes["Monad"] = "monad";
BlockchainTypes["Soneium"] = "soneium";
BlockchainTypes["None"] = "none";
})(BlockchainTypes || (BlockchainTypes = {}));
var ContentSource;
(function (ContentSource) {
ContentSource["tiktok"] = "tiktok";
ContentSource["youtube"] = "youtube";
ContentSource["youtubeMusic"] = "youtube-music";
ContentSource["instagram"] = "instagram";
ContentSource["x"] = "x";
ContentSource["spotify"] = "spotify";
ContentSource["soundcloud"] = "soundcloud";
ContentSource["website"] = "website";
})(ContentSource || (ContentSource = {}));
/**
*
* Main common types
*
*/
var Status;
(function (Status) {
Status["NON_INIT"] = "Non-Initialized";
Status["INIT"] = "Initializing";
Status["COLLECTING"] = "Collecting";
Status["SUCCESS"] = "Success";
Status["NO_LOCATION"] = "No-Location";
Status["FAILED"] = "Failed";
Status["ERROR"] = "Error";
Status["BLOCK"] = "Block";
})(Status || (Status = {}));
var Environment;
(function (Environment) {
Environment["DEVELOPMENT"] = "DEVELOPMENT";
Environment["STAGING"] = "STAGING";
Environment["PRODUCTION"] = "PRODUCTION";
})(Environment || (Environment = {}));
var DistanceUnits;
(function (DistanceUnits) {
DistanceUnits["meter"] = "m";
DistanceUnits["kilometers"] = "km";
DistanceUnits["miles"] = "mi";
DistanceUnits["ft"] = "feet";
})(DistanceUnits || (DistanceUnits = {}));
export { Base, BlockchainTypes, ContentSource, ContractEnvironment, ContractStatus, DistanceUnits, Environment, utils as MentaportUtils, Status, applyCombination };
//# sourceMappingURL=index.js.map