rstify-ask/index.js

Restify is a comprehensive npm package that streamlines and enhances the handling of HTTP requests in JavaScript applications.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.RestifyHeaders = exports.RestifyError = exports.HttpStatusCode = exports.CanceledError = exports.CancelToken = exports.Cancel = void 0;
exports.formToJSON = formToJSON;
exports.getAdapter = getAdapter;
exports.isCancel = isCancel;
exports.isRestifyError = isRestifyError;
exports.mergeConfig = mergeConfig;
exports.spread = spread;
exports.toFormData = toFormData;
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Cancel = exports.Cancel = /*#__PURE__*/_createClass(function Cancel(message) {
  _classCallCheck(this, Cancel);
  this.message = message;
});
var CancelToken = exports.CancelToken = /*#__PURE__*/function () {
  function CancelToken(executor) {
    var _this = this;
    _classCallCheck(this, CancelToken);
    var cancel;
    this.promise = new Promise(function (resolve, reject) {
      cancel = function cancel() {
        reject(new Cancel('Operation canceled by the user.'));
      };
      executor(cancel);
    });
    this.throwIfRequested = function () {
      if (_this.reason) {
        throw _this.reason;
      }
    };
  }
  _createClass(CancelToken, null, [{
    key: "source",
    value: function source() {
      var cancel;
      var token = new CancelToken(function (c) {
        cancel = c;
      });
      return {
        token: token,
        cancel: cancel
      };
    }
  }]);
  return CancelToken;
}();
var CanceledError = exports.CanceledError = /*#__PURE__*/function (_Error) {
  _inherits(CanceledError, _Error);
  function CanceledError(message) {
    var _this2;
    _classCallCheck(this, CanceledError);
    _this2 = _callSuper(this, CanceledError, [message]);
    _this2.name = 'CanceledError';
    return _this2;
  }
  return _createClass(CanceledError);
}( /*#__PURE__*/_wrapNativeSuper(Error));
var RestifyError = exports.RestifyError = /*#__PURE__*/function (_Error2) {
  _inherits(RestifyError, _Error2);
  function RestifyError(message, config, code, request, response) {
    var _this3;
    _classCallCheck(this, RestifyError);
    _this3 = _callSuper(this, RestifyError, [message]);
    _this3.name = 'RestifyError';
    _this3.config = config;
    _this3.code = code;
    _this3.request = request;
    _this3.response = response;
    return _this3;
  }
  return _createClass(RestifyError);
}( /*#__PURE__*/_wrapNativeSuper(Error));
var HttpStatusCode = exports.HttpStatusCode = /*#__PURE__*/_createClass(function HttpStatusCode() {
  _classCallCheck(this, HttpStatusCode);
});
_defineProperty(HttpStatusCode, "OK", 200);
_defineProperty(HttpStatusCode, "CREATED", 201);
_defineProperty(HttpStatusCode, "ACCEPTED", 202);
_defineProperty(HttpStatusCode, "NO_CONTENT", 204);
_defineProperty(HttpStatusCode, "MOVED_PERMANENTLY", 301);
_defineProperty(HttpStatusCode, "FOUND", 302);
_defineProperty(HttpStatusCode, "SEE_OTHER", 303);
_defineProperty(HttpStatusCode, "NOT_MODIFIED", 304);
_defineProperty(HttpStatusCode, "TEMPORARY_REDIRECT", 307);
_defineProperty(HttpStatusCode, "PERMANENT_REDIRECT", 308);
_defineProperty(HttpStatusCode, "BAD_REQUEST", 400);
_defineProperty(HttpStatusCode, "UNAUTHORIZED", 401);
_defineProperty(HttpStatusCode, "FORBIDDEN", 403);
_defineProperty(HttpStatusCode, "NOT_FOUND", 404);
_defineProperty(HttpStatusCode, "METHOD_NOT_ALLOWED", 405);
_defineProperty(HttpStatusCode, "CONFLICT", 409);
_defineProperty(HttpStatusCode, "GONE", 410);
_defineProperty(HttpStatusCode, "PRECONDITION_FAILED", 412);
_defineProperty(HttpStatusCode, "UNPROCESSABLE_ENTITY", 422);
_defineProperty(HttpStatusCode, "INTERNAL_SERVER_ERROR", 500);
_defineProperty(HttpStatusCode, "NOT_IMPLEMENTED", 501);
_defineProperty(HttpStatusCode, "BAD_GATEWAY", 502);
_defineProperty(HttpStatusCode, "SERVICE_UNAVAILABLE", 503);
_defineProperty(HttpStatusCode, "GATEWAY_TIMEOUT", 504);
var RestifyHeaders = exports.RestifyHeaders = /*#__PURE__*/_createClass(function RestifyHeaders() {
  _classCallCheck(this, RestifyHeaders);
});
// Common headers
_defineProperty(RestifyHeaders, "ACCEPT", 'Accept');
_defineProperty(RestifyHeaders, "ACCEPT_CHARSET", 'Accept-Charset');
_defineProperty(RestifyHeaders, "ACCEPT_ENCODING", 'Accept-Encoding');
_defineProperty(RestifyHeaders, "ACCEPT_LANGUAGE", 'Accept-Language');
_defineProperty(RestifyHeaders, "AUTHORIZATION", 'Authorization');
_defineProperty(RestifyHeaders, "CACHE_CONTROL", 'Cache-Control');
_defineProperty(RestifyHeaders, "CONTENT_TYPE", 'Content-Type');
_defineProperty(RestifyHeaders, "USER_AGENT", 'User-Agent');
// Content type headers
_defineProperty(RestifyHeaders, "CONTENT_TYPE_JSON", 'application/json');
_defineProperty(RestifyHeaders, "CONTENT_TYPE_FORM_URLENCODED", 'application/x-www-form-urlencoded');
_defineProperty(RestifyHeaders, "CONTENT_TYPE_XML", 'application/xml');
_defineProperty(RestifyHeaders, "CONTENT_TYPE_TEXT", 'text/plain');
_defineProperty(RestifyHeaders, "CONTENT_TYPE_HTML", 'text/html');
_defineProperty(RestifyHeaders, "CONTENT_TYPE_MULTIPART", 'multipart/form-data');
// Caching headers
_defineProperty(RestifyHeaders, "ETAG", 'ETag');
_defineProperty(RestifyHeaders, "IF_MATCH", 'If-Match');
_defineProperty(RestifyHeaders, "IF_NONE_MATCH", 'If-None-Match');
_defineProperty(RestifyHeaders, "IF_MODIFIED_SINCE", 'If-Modified-Since');
_defineProperty(RestifyHeaders, "IF_UNMODIFIED_SINCE", 'If-Unmodified-Since');
// Authentication headers
_defineProperty(RestifyHeaders, "WWW_AUTHENTICATE", 'WWW-Authenticate');
// CORS headers
_defineProperty(RestifyHeaders, "ACCESS_CONTROL_ALLOW_ORIGIN", 'Access-Control-Allow-Origin');
_defineProperty(RestifyHeaders, "ACCESS_CONTROL_ALLOW_METHODS", 'Access-Control-Allow-Methods');
_defineProperty(RestifyHeaders, "ACCESS_CONTROL_ALLOW_HEADERS", 'Access-Control-Allow-Headers');
_defineProperty(RestifyHeaders, "ACCESS_CONTROL_MAX_AGE", 'Access-Control-Max-Age');
_defineProperty(RestifyHeaders, "ACCESS_CONTROL_EXPOSE_HEADERS", 'Access-Control-Expose-Headers');
_defineProperty(RestifyHeaders, "ACCESS_CONTROL_ALLOW_CREDENTIALS", 'Access-Control-Allow-Credentials');
// Security headers
_defineProperty(RestifyHeaders, "STRICT_TRANSPORT_SECURITY", 'Strict-Transport-Security');
_defineProperty(RestifyHeaders, "CONTENT_SECURITY_POLICY", 'Content-Security-Policy');
_defineProperty(RestifyHeaders, "X_CONTENT_TYPE_OPTIONS", 'X-Content-Type-Options');
_defineProperty(RestifyHeaders, "X_FRAME_OPTIONS", 'X-Frame-Options');
_defineProperty(RestifyHeaders, "X_XSS_PROTECTION", 'X-XSS-Protection');
// Cookies and session headers
_defineProperty(RestifyHeaders, "SET_COOKIE", 'Set-Cookie');
_defineProperty(RestifyHeaders, "COOKIE", 'Cookie');
// Compression headers
_defineProperty(RestifyHeaders, "CONTENT_ENCODING", 'Content-Encoding');
_defineProperty(RestifyHeaders, "CONTENT_DECODING", 'Content-Decoding');
// Custom headers
_defineProperty(RestifyHeaders, "X_CUSTOM_HEADER", 'X-Custom-Header');
function isCancel(value) {
  try {
    return value instanceof Cancel;
  } catch (error) {
    console.log(error);
  }
}
function isRestifyError(value) {
  try {
    return value instanceof RestifyError;
  } catch (error) {
    console.log(error);
  }
}
function spread(callback) {
  try {
    return function wrap(arr) {
      return callback.apply(null, arr);
    };
  } catch (error) {
    console.log(error);
  }
}
function toFormData(obj) {
  try {
    var formData = new FormData();
    for (var key in obj) {
      if (obj.hasOwnProperty(key)) {
        formData.append(key, obj[key]);
      }
    }
    return formData;
  } catch (error) {
    console.log(error);
  }
}
function formToJSON(formData) {
  try {
    var jsonObject = {};
    formData === null || formData === void 0 || formData.forEach(function (value, key) {
      // Check if the key already exists in the object
      if (jsonObject.hasOwnProperty(key)) {
        // If it's an array, push the new value
        if (!Array.isArray(jsonObject[key])) {
          jsonObject[key] = [jsonObject[key]];
        }
        jsonObject[key].push(value);
      } else {
        // If the key doesn't exist, create a new key-value pair
        jsonObject[key] = value;
      }
    });
    return JSON.stringify(jsonObject);
  } catch (error) {
    console.log(error);
  }
}
function getAdapter(config) {
  try {
    // If running in a browser environment
    if (typeof window !== 'undefined' && window.fetch) {
      return function (resolve, reject) {
        var method = config.method,
          url = config.url,
          headers = config.headers,
          data = config.data,
          cancelToken = config.cancelToken;
        var options = {
          method: method,
          headers: _objectSpread(_objectSpread({}, headers), {}, {
            'Content-Type': 'application/json'
          }),
          body: JSON.stringify(data)
        };
        if (cancelToken) {
          cancelToken.promise.then(function (reason) {
            reject(reason);
          });
        }
        fetch(url, options).then(function (response) {
          // Check if the response has a JSON content type
          var contentType = response.headers.get('content-type');
          var isJsonResponse = contentType && contentType.includes('application/json');
          return isJsonResponse ? response.json() // Parse JSON response
          : response.text(); // Otherwise, treat as text
        }).then(function (responseData) {
          // Resolve with parsed data
          resolve({
            status: responseData.status || 200,
            data: responseData
          });
        })["catch"](function (error) {
          // Enhance error logging
          console.error('Fetch error:', error);
          reject(error);
        });
      };
    }

    // If the environment is not recognized
    throw new Error('Restify does not support the current environment');
  } catch (error) {
    console.log(error);
  }
}
function mergeConfig(config1, config2) {
  // Create a new object to hold the merged configuration
  var mergedConfig = Object.assign({}, config1);

  // Iterate through config2 and add or overwrite properties in mergedConfig
  for (var key in config2) {
    if (config2.hasOwnProperty(key)) {
      // Special handling for headers, merging them instead of overwriting
      if (key === 'headers' && config1.headers && _typeof(config1.headers) === 'object') {
        mergedConfig.headers = Object.assign({}, config1.headers, config2.headers);
      } else if (key === 'params' && config1.params && _typeof(config1.params) === 'object') {
        // Merge params instead of overwriting
        mergedConfig.params = Object.assign({}, config1.params, config2.params);
      } else {
        mergedConfig[key] = config2[key];
      }
    }
  }
  return mergedConfig;
}
function restify(config) {
  try {
    return new Promise(function (resolve, reject) {
      var adapter = getAdapter(config);
      var cancelToken = config.cancelToken;
      if (cancelToken) {
        cancelToken.promise.then(function (reason) {
          reject(reason);
        });
      }
      adapter(resolve, reject);
    });
  } catch (error) {
    console.log(error);
  }
}
var Restify = /*#__PURE__*/function () {
  function Restify() {
    _classCallCheck(this, Restify);
  }
  _createClass(Restify, null, [{
    key: "request",
    value: function request(config) {
      return restify(config);
    }
  }, {
    key: "get",
    value: function get(url, config) {
      return restify(mergeConfig(config, {
        method: 'GET',
        url: url
      }));
    }
  }, {
    key: "delete",
    value: function _delete(url, config) {
      return restify(mergeConfig(config, {
        method: 'DELETE',
        url: url
      }));
    }
  }, {
    key: "head",
    value: function head(url, config) {
      return restify(mergeConfig(config, {
        method: 'HEAD',
        url: url
      }));
    }
  }, {
    key: "options",
    value: function options(url, config) {
      return restify(mergeConfig(config, {
        method: 'OPTIONS',
        url: url
      }));
    }
  }, {
    key: "post",
    value: function post(url, data, config) {
      return restify(mergeConfig(config, {
        method: 'POST',
        url: url,
        data: data
      }));
    }
  }, {
    key: "put",
    value: function put(url, data, config) {
      return restify(mergeConfig(config, {
        method: 'PUT',
        url: url,
        data: data
      }));
    }
  }, {
    key: "patch",
    value: function patch(url, data, config) {
      return restify(mergeConfig(config, {
        method: 'PATCH',
        url: url,
        data: data
      }));
    }
  }, {
    key: "postForm",
    value: function postForm(url, data, config) {
      var formData = toFormData(data);
      return restify(mergeConfig(config, {
        method: 'POST',
        url: url,
        data: formData
      }));
    }
  }, {
    key: "putForm",
    value: function putForm(url, data, config) {
      var formData = toFormData(data);
      return restify(mergeConfig(config, {
        method: 'PUT',
        url: url,
        data: formData
      }));
    }
  }, {
    key: "patchForm",
    value: function patchForm(url, data, config) {
      var formData = toFormData(data);
      return restify(mergeConfig(config, {
        method: 'PATCH',
        url: url,
        data: formData
      }));
    }

    // Added a new method to handle dynamic authorization
  }, {
    key: "withAuthorization",
    value: function withAuthorization(authorizationToken) {
      return {
        get: function get(url) {
          var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          return Restify.get(url, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        "delete": function _delete(url) {
          var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          return Restify["delete"](url, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        head: function head(url) {
          var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          return Restify.head(url, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        options: function options(url) {
          var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
          return Restify.options(url, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        post: function post(url, data) {
          var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
          return Restify.post(url, data, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        put: function put(url, data) {
          var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
          return Restify.put(url, data, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        patch: function patch(url, data) {
          var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
          return Restify.patch(url, data, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        postForm: function postForm(url, data) {
          var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
          return Restify.postForm(url, data, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        putForm: function putForm(url, data) {
          var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
          return Restify.putForm(url, data, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        },
        patchForm: function patchForm(url, data) {
          var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
          return Restify.patchForm(url, data, mergeConfig(config, {
            headers: {
              Authorization: authorizationToken
            }
          }));
        }
      };
    }
  }]);
  return Restify;
}(); // Exporting individual components
restify.Cancel = Cancel;
restify.CancelToken = CancelToken;
restify.CanceledError = CanceledError;
restify.RestifyError = RestifyError;
restify.HttpStatusCode = HttpStatusCode;
restify.RestifyHeaders = RestifyHeaders;
restify.isCancel = isCancel;
restify.isRestifyError = isRestifyError;
restify.spread = spread;
restify.toFormData = toFormData;
restify.formToJSON = formToJSON;
restify.getAdapter = getAdapter;
restify.mergeConfig = mergeConfig;

// Exporting individual components
var _default = exports["default"] = Restify;