@medipass/web-sdk 12.11.1 → 12.11.2-feature-axios-to-fetch.2

package/lib/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from '../utils/http-client';
 export * from './abr';
 export * from './application';
 export * from './blacklist-bank-account';

package/lib/types/index.js

@@ -2,10 +2,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var utils_httpClient = require('../utils/http-client.js');
 var types_documents = require('./documents.js');
 var types_filterOption = require('./filter-option.js');
+require('@babel/runtime/regenerator');
+require('@babel/runtime/helpers/defineProperty');
+require('@babel/runtime/helpers/asyncToGenerator');
 
 
 
+exports.createHttpClient = utils_httpClient.createHttpClient;
 exports.HealthPointApplicationStatus = types_documents.HealthPointApplicationStatus;
 exports.FilterGroup = types_filterOption.FilterGroup;

package/lib/utils/application.js

@@ -4,16 +4,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 require('@babel/runtime/regenerator');
 require('@babel/runtime/helpers/asyncToGenerator');
-var utils_request = require('../staff-d7246b15.js');
+var utils_request = require('../staff-b353f63a.js');
 require('@babel/runtime/helpers/defineProperty');
 require('lodash/merge');
 require('lodash/uniq');
-require('axios');
+require('./http-client.js');
 require('date-fns/differenceInSeconds');
 require('jwt-decode');
 require('lodash/forOwn');
 require('lodash/get');
-require('./get-axios-error.js');
+require('./get-http-error.js');
 require('./does-param-exist.js');
 require('./param-error.js');
 require('@babel/runtime/helpers/inheritsLoose');

package/lib/utils/get-http-error.d.ts

@@ -0,0 +1,12 @@
+import type { HttpClientError, HttpClientResponse } from './http-client';
+/**
+ * Extracts a standardized error response from an HttpClientError.
+ * Maintains backwards compatibility with the axios error structure.
+ *
+ * @param error - The HTTP client error
+ * @returns The response object if available, or a message-only object for network errors
+ */
+declare const getHttpError: (error: HttpClientError) => HttpClientResponse | {
+    message: string;
+};
+export default getHttpError;

package/lib/utils/get-http-error.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Extracts a standardized error response from an HttpClientError.
+ * Maintains backwards compatibility with the axios error structure.
+ *
+ * @param error - The HTTP client error
+ * @returns The response object if available, or a message-only object for network errors
+ */
+var getHttpError = function getHttpError(error) {
+  if (error.response) {
+    return error.response;
+  }
+
+  return {
+    message: error.message
+  };
+};
+
+exports["default"] = getHttpError;

package/lib/utils/http-client.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Custom HTTP client wrapper around native fetch API.
+ * Replaces axios with a minimal implementation that provides:
+ * - Request/response interceptors (async supported)
+ * - Axios-compatible response structure
+ * - Automatic JSON parsing when Content-Type is application/json
+ * - Error rejection on 4xx/5xx responses (axios behavior)
+ *
+ * Based on Kent C. Dodds' pattern:
+ * https://kentcdodds.com/blog/replace-axios-with-a-simple-custom-fetch-wrapper
+ */
+export interface HttpClientConfig {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: BodyInit;
+    params?: Record<string, any>;
+    data?: any;
+    tokenType?: string;
+    skipDeviceCheck?: boolean;
+    [key: string]: any;
+}
+export interface HttpClientResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: HttpClientConfig;
+}
+export interface HttpClientError extends Error {
+    response?: HttpClientResponse;
+    config?: HttpClientConfig;
+}
+declare type RequestInterceptorFulfilled = (config: HttpClientConfig) => HttpClientConfig | Promise<HttpClientConfig>;
+declare type RequestInterceptorRejected = (error: any) => any;
+declare type ResponseInterceptorFulfilled = (response: HttpClientResponse) => HttpClientResponse | Promise<HttpClientResponse>;
+declare type ResponseInterceptorRejected = (error: HttpClientError) => any;
+interface RequestInterceptor {
+    fulfilled: RequestInterceptorFulfilled;
+    rejected?: RequestInterceptorRejected;
+}
+interface ResponseInterceptor {
+    fulfilled: ResponseInterceptorFulfilled;
+    rejected?: ResponseInterceptorRejected;
+}
+interface InterceptorManager<T> {
+    handlers: Array<T | null>;
+    use(fulfilled: T extends RequestInterceptor ? RequestInterceptorFulfilled : ResponseInterceptorFulfilled, rejected?: T extends RequestInterceptor ? RequestInterceptorRejected : ResponseInterceptorRejected): number;
+    eject(id: number): void;
+}
+export interface HttpClient {
+    (url: string, config?: HttpClientConfig): Promise<HttpClientResponse>;
+    defaults: {
+        headers: {
+            post: Record<string, string>;
+            common: Record<string, string>;
+        };
+    };
+    interceptors: {
+        request: InterceptorManager<RequestInterceptor>;
+        response: InterceptorManager<ResponseInterceptor>;
+    };
+}
+/**
+ * Creates a new HTTP client instance with interceptor support.
+ * This is the fetch-based replacement for axios.create()
+ */
+export declare function createHttpClient(): HttpClient;
+export {};

package/lib/utils/http-client.js

@@ -0,0 +1,414 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _regeneratorRuntime = require('@babel/runtime/regenerator');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * Custom HTTP client wrapper around native fetch API.
+ * Replaces axios with a minimal implementation that provides:
+ * - Request/response interceptors (async supported)
+ * - Axios-compatible response structure
+ * - Automatic JSON parsing when Content-Type is application/json
+ * - Error rejection on 4xx/5xx responses (axios behavior)
+ *
+ * Based on Kent C. Dodds' pattern:
+ * https://kentcdodds.com/blog/replace-axios-with-a-simple-custom-fetch-wrapper
+ */
+
+/**
+ * Creates a new HTTP client instance with interceptor support.
+ * This is the fetch-based replacement for axios.create()
+ */
+function createHttpClient() {
+  var requestInterceptors = [];
+  var responseInterceptors = [];
+  var defaults = {
+    headers: {
+      post: {},
+      common: {}
+    }
+  };
+
+  function httpClient(_x, _x2) {
+    return _httpClient.apply(this, arguments);
+  } // Attach defaults and interceptor management
+
+
+  function _httpClient() {
+    _httpClient = _asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee(url, config) {
+      var processedConfig, _iterator, _step, _interceptor2, _result2, method, headers, fetchOptions, finalUrl, searchParams, queryString, fetchResponse, _error, _iterator2, _step2, interceptor, result, responseHeaders, responseData, contentType, contentLength, response, _error2, _iterator3, _step3, _interceptor, _result, _iterator4, _step4, _interceptor3;
+
+      return _regeneratorRuntime__default["default"].wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (config === void 0) {
+                config = {};
+              }
+
+              processedConfig = _objectSpread({}, config); // Run request interceptors (in order, skip nulls from eject)
+
+              _iterator = _createForOfIteratorHelperLoose(requestInterceptors);
+
+            case 3:
+              if ((_step = _iterator()).done) {
+                _context.next = 22;
+                break;
+              }
+
+              _interceptor2 = _step.value;
+
+              if (!(_interceptor2 === null)) {
+                _context.next = 7;
+                break;
+              }
+
+              return _context.abrupt("continue", 20);
+
+            case 7:
+              _context.prev = 7;
+              _context.next = 10;
+              return _interceptor2.fulfilled(processedConfig);
+
+            case 10:
+              processedConfig = _context.sent;
+              _context.next = 20;
+              break;
+
+            case 13:
+              _context.prev = 13;
+              _context.t0 = _context["catch"](7);
+
+              if (!_interceptor2.rejected) {
+                _context.next = 19;
+                break;
+              }
+
+              _result2 = _interceptor2.rejected(_context.t0);
+
+              if (!(_result2 instanceof Promise)) {
+                _context.next = 19;
+                break;
+              }
+
+              return _context.abrupt("return", _result2);
+
+            case 19:
+              throw _context.t0;
+
+            case 20:
+              _context.next = 3;
+              break;
+
+            case 22:
+              // Build headers - merge defaults with config headers
+              method = (processedConfig.method || 'GET').toUpperCase();
+              headers = _objectSpread({}, defaults.headers.common, {}, method === 'POST' || method === 'PUT' || method === 'PATCH' ? defaults.headers.post : {}, {}, processedConfig.headers); // Build fetch options
+
+              fetchOptions = {
+                method: method,
+                headers: headers
+              }; // Handle request body
+
+              if (processedConfig.data !== undefined) {
+                if (processedConfig.data instanceof FormData) {
+                  fetchOptions.body = processedConfig.data; // Remove Content-Type for FormData - browser sets it with boundary
+
+                  delete fetchOptions.headers['Content-Type'];
+                } else if (typeof processedConfig.data === 'object') {
+                  fetchOptions.body = JSON.stringify(processedConfig.data);
+                } else {
+                  fetchOptions.body = processedConfig.data;
+                }
+              } // Handle query params
+
+
+              finalUrl = url;
+
+              if (processedConfig.params) {
+                searchParams = new URLSearchParams();
+                Object.entries(processedConfig.params).forEach(function (_ref) {
+                  var key = _ref[0],
+                      value = _ref[1];
+
+                  if (value !== undefined && value !== null) {
+                    if (Array.isArray(value)) {
+                      value.forEach(function (v) {
+                        return searchParams.append(key, String(v));
+                      });
+                    } else {
+                      searchParams.append(key, String(value));
+                    }
+                  }
+                });
+                queryString = searchParams.toString();
+
+                if (queryString) {
+                  finalUrl += (url.includes('?') ? '&' : '?') + queryString;
+                }
+              } // Make the request
+
+
+              _context.prev = 28;
+              _context.next = 31;
+              return fetch(finalUrl, fetchOptions);
+
+            case 31:
+              fetchResponse = _context.sent;
+              _context.next = 50;
+              break;
+
+            case 34:
+              _context.prev = 34;
+              _context.t1 = _context["catch"](28);
+              // Network error (no response)
+              _error = new Error(_context.t1 instanceof Error ? _context.t1.message : 'Network Error');
+              _error.config = processedConfig; // Run response error interceptors
+
+              _iterator2 = _createForOfIteratorHelperLoose(responseInterceptors);
+
+            case 39:
+              if ((_step2 = _iterator2()).done) {
+                _context.next = 49;
+                break;
+              }
+
+              interceptor = _step2.value;
+
+              if (!(interceptor === null)) {
+                _context.next = 43;
+                break;
+              }
+
+              return _context.abrupt("continue", 47);
+
+            case 43:
+              if (!interceptor.rejected) {
+                _context.next = 47;
+                break;
+              }
+
+              result = interceptor.rejected(_error);
+
+              if (!(result instanceof Promise)) {
+                _context.next = 47;
+                break;
+              }
+
+              return _context.abrupt("return", result);
+
+            case 47:
+              _context.next = 39;
+              break;
+
+            case 49:
+              throw _error;
+
+            case 50:
+              // Parse response headers into plain object (lowercase keys like axios)
+              responseHeaders = {};
+              fetchResponse.headers.forEach(function (value, key) {
+                responseHeaders[key.toLowerCase()] = value;
+              }); // Parse response body based on Content-Type
+
+              contentType = fetchResponse.headers.get('content-type');
+              contentLength = fetchResponse.headers.get('content-length'); // Only try to parse body if there's content
+
+              if (!(contentLength === '0' || fetchResponse.status === 204)) {
+                _context.next = 58;
+                break;
+              }
+
+              responseData = null;
+              _context.next = 75;
+              break;
+
+            case 58:
+              if (!(contentType != null && contentType.includes('application/json'))) {
+                _context.next = 72;
+                break;
+              }
+
+              _context.prev = 59;
+              _context.next = 62;
+              return fetchResponse.json();
+
+            case 62:
+              responseData = _context.sent;
+              _context.next = 70;
+              break;
+
+            case 65:
+              _context.prev = 65;
+              _context.t2 = _context["catch"](59);
+              _context.next = 69;
+              return fetchResponse.text();
+
+            case 69:
+              responseData = _context.sent;
+
+            case 70:
+              _context.next = 75;
+              break;
+
+            case 72:
+              _context.next = 74;
+              return fetchResponse.text();
+
+            case 74:
+              responseData = _context.sent;
+
+            case 75:
+              // Build axios-like response object
+              response = {
+                data: responseData,
+                status: fetchResponse.status,
+                statusText: fetchResponse.statusText,
+                headers: responseHeaders,
+                config: processedConfig
+              }; // Check for HTTP errors (fetch doesn't reject on 4xx/5xx, but axios does)
+
+              if (fetchResponse.ok) {
+                _context.next = 92;
+                break;
+              }
+
+              _error2 = new Error("Request failed with status code " + fetchResponse.status);
+              _error2.response = response;
+              _error2.config = processedConfig; // Run response error interceptors
+
+              _iterator3 = _createForOfIteratorHelperLoose(responseInterceptors);
+
+            case 81:
+              if ((_step3 = _iterator3()).done) {
+                _context.next = 91;
+                break;
+              }
+
+              _interceptor = _step3.value;
+
+              if (!(_interceptor === null)) {
+                _context.next = 85;
+                break;
+              }
+
+              return _context.abrupt("continue", 89);
+
+            case 85:
+              if (!_interceptor.rejected) {
+                _context.next = 89;
+                break;
+              }
+
+              _result = _interceptor.rejected(_error2);
+
+              if (!(_result instanceof Promise)) {
+                _context.next = 89;
+                break;
+              }
+
+              return _context.abrupt("return", _result);
+
+            case 89:
+              _context.next = 81;
+              break;
+
+            case 91:
+              throw _error2;
+
+            case 92:
+              _iterator4 = _createForOfIteratorHelperLoose(responseInterceptors);
+
+            case 93:
+              if ((_step4 = _iterator4()).done) {
+                _context.next = 102;
+                break;
+              }
+
+              _interceptor3 = _step4.value;
+
+              if (!(_interceptor3 === null)) {
+                _context.next = 97;
+                break;
+              }
+
+              return _context.abrupt("continue", 100);
+
+            case 97:
+              _context.next = 99;
+              return _interceptor3.fulfilled(response);
+
+            case 99:
+              response = _context.sent;
+
+            case 100:
+              _context.next = 93;
+              break;
+
+            case 102:
+              return _context.abrupt("return", response);
+
+            case 103:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, null, [[7, 13], [28, 34], [59, 65]]);
+    }));
+    return _httpClient.apply(this, arguments);
+  }
+
+  httpClient.defaults = defaults;
+  httpClient.interceptors = {
+    request: {
+      handlers: requestInterceptors,
+      use: function use(fulfilled, rejected) {
+        return requestInterceptors.push({
+          fulfilled: fulfilled,
+          rejected: rejected
+        }) - 1;
+      },
+      eject: function eject(id) {
+        if (requestInterceptors[id]) {
+          requestInterceptors[id] = null;
+        }
+      }
+    },
+    response: {
+      handlers: responseInterceptors,
+      use: function use(fulfilled, rejected) {
+        return responseInterceptors.push({
+          fulfilled: fulfilled,
+          rejected: rejected
+        }) - 1;
+      },
+      eject: function eject(id) {
+        if (responseInterceptors[id]) {
+          responseInterceptors[id] = null;
+        }
+      }
+    }
+  };
+  return httpClient;
+}
+
+exports.createHttpClient = createHttpClient;

package/lib/utils/professions.js

@@ -7,14 +7,14 @@ require('@babel/runtime/helpers/defineProperty');
 require('@babel/runtime/helpers/asyncToGenerator');
 require('lodash/uniq');
 require('lodash/flatten');
-var utils_request = require('../staff-d7246b15.js');
+var utils_request = require('../staff-b353f63a.js');
 require('lodash/merge');
-require('axios');
+require('./http-client.js');
 require('date-fns/differenceInSeconds');
 require('jwt-decode');
 require('lodash/forOwn');
 require('lodash/get');
-require('./get-axios-error.js');
+require('./get-http-error.js');
 require('./does-param-exist.js');
 require('./param-error.js');
 require('@babel/runtime/helpers/inheritsLoose');

package/lib/utils/request.d.ts

@@ -5,5 +5,5 @@ import type { MedipassRequestOpts } from '../types';
 export declare const stripBottleneckOpts: (axiosRequestOpts?: Record<string, any>) => {
     [x: string]: any;
 };
-declare const request: (medipassRequestOpts: MedipassRequestOpts, axiosRequestOpts?: Record<string, any>) => Promise<any>;
+declare const request: (medipassRequestOpts: MedipassRequestOpts, httpRequestOpts?: Record<string, any>) => Promise<any>;
 export default request;

package/lib/utils/request.js

@@ -6,11 +6,11 @@ require('@babel/runtime/regenerator');
 require('@babel/runtime/helpers/asyncToGenerator');
 require('@babel/runtime/helpers/defineProperty');
 require('lodash/get');
-var utils_request = require('../staff-d7246b15.js');
-require('./get-axios-error.js');
+var utils_request = require('../staff-b353f63a.js');
+require('./get-http-error.js');
 require('lodash/merge');
 require('lodash/uniq');
-require('axios');
+require('./http-client.js');
 require('date-fns/differenceInSeconds');
 require('jwt-decode');
 require('lodash/forOwn');

package/lib/utils/staff.js

@@ -7,13 +7,13 @@ require('@babel/runtime/regenerator');
 require('@babel/runtime/helpers/asyncToGenerator');
 require('lodash/merge');
 require('lodash/uniq');
-var utils_request = require('../staff-d7246b15.js');
-require('axios');
+var utils_request = require('../staff-b353f63a.js');
+require('./http-client.js');
 require('date-fns/differenceInSeconds');
 require('jwt-decode');
 require('lodash/forOwn');
 require('lodash/get');
-require('./get-axios-error.js');
+require('./get-http-error.js');
 require('./does-param-exist.js');
 require('./param-error.js');
 require('@babel/runtime/helpers/inheritsLoose');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medipass/web-sdk",
-  "version": "12.11.1",
+  "version": "12.11.2-feature-axios-to-fetch.2",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -33,7 +33,6 @@
   },
   "dependencies": {
     "@babel/runtime": "7.8.4",
-    "axios": "0.21.1",
     "compare-versions": "3.4.0",
     "date-fns": "2.16.1",
     "jwt-decode": "2.2.0",
@@ -51,7 +50,7 @@
     "@types/mocha": "9.1.1",
     "@types/node": "20.3.2",
     "@types/pify": "5.0.4",
-    "axios-mock-adapter": "1.21.2",
+    "jest-fetch-mock": "3.0.3",
     "query-string": "7.0.0",
     "rimraf": "2.6.2",
     "typescript": "4.7.4"
@@ -59,5 +58,5 @@
   "resolutions": {
     "react-scripts/**/@typescript-eslint/eslint-plugin": "5.32.0"
   },
-  "gitHead": "adcb709728d2b59ec7bc7ad70cd284a2bc329e52"
+  "gitHead": "b112021aecc5bb3aefda615f34e65c0ff1dcac3c"
 }