appstore-connect-sdk 1.2.1 → 1.3.1

package/dist/main.js

@@ -47,6 +47,135 @@ var Configuration = class {
   }
 };
 var DefaultConfig = new Configuration();
+var BaseAPI = class {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.fetchApi = async (url, init) => {
+      let fetchParams = { url, init };
+      for (const middleware of this.middleware) {
+        if (middleware.pre) {
+          fetchParams = await middleware.pre({
+            fetch: this.fetchApi,
+            ...fetchParams
+          }) || fetchParams;
+        }
+      }
+      let response = void 0;
+      try {
+        response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+      } catch (e) {
+        for (const middleware of this.middleware) {
+          if (middleware.onError) {
+            response = await middleware.onError({
+              fetch: this.fetchApi,
+              url: fetchParams.url,
+              init: fetchParams.init,
+              error: e,
+              response: response ? response.clone() : void 0
+            }) || response;
+          }
+        }
+        if (response === void 0) {
+          if (e instanceof Error) {
+            throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+          } else {
+            throw e;
+          }
+        }
+      }
+      for (const middleware of this.middleware) {
+        if (middleware.post) {
+          response = await middleware.post({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            response: response.clone()
+          }) || response;
+        }
+      }
+      return response;
+    };
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    const init = {
+      ...overriddenInit,
+      body: isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body) ? overriddenInit.body : JSON.stringify(overriddenInit.body)
+    };
+    return { url, init };
+  }
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+    this.name = "ResponseError";
+  }
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+    this.name = "FetchError";
+  }
+};
 function querystring(params, prefix = "") {
   return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
 }
@@ -965,12 +1094,13 @@ var AppStoreConnectAPI = class {
   }
   /**
    * Returns the current bearer token, generating a new one if necessary.
+   * The token will be refreshed if it's close to expiration (within 2 minutes).
    */
   async getConfiguration() {
     const latestBearerTokenDuration = this.bearerTokenGeneratedAt ? Date.now() - this.bearerTokenGeneratedAt : 0;
     const expirationDurationMs = 1e3 * (this.options.expirationDuration ?? DEFAULT_EXPIRATION_DURATION_SECONDS);
-    const hasExpired = latestBearerTokenDuration > expirationDurationMs;
-    if (!this.configuration || hasExpired) {
+    const shouldRefresh = !this.configuration || latestBearerTokenDuration > expirationDurationMs || latestBearerTokenDuration > expirationDurationMs - 2 * 60 * 1e3;
+    if (shouldRefresh) {
       await this.genConfiguration();
     }
     return this.configuration;
@@ -983,6 +1113,39 @@ var AppStoreConnectAPI = class {
   async create(apiClass) {
     return new apiClass(await this.getConfiguration());
   }
+  /**
+   * Makes an API request.
+   * @param context - The request context for the API request.
+   * @param initOverrides - (Optional) The request options to use for the API request.
+   * @returns The response from the API request.
+   */
+  async request(context, initOverrides) {
+    if (!context.url && !context.path) {
+      throw new Error("No url or path provided");
+    }
+    const _context = { ...context };
+    if (!_context.path && _context.url) {
+      if (_context.url.startsWith(BASE_PATH)) {
+        _context.path = _context.url.replace(BASE_PATH, "");
+      } else {
+        throw new Error("url must start with " + BASE_PATH);
+      }
+    }
+    if (!_context.method) {
+      _context.method = "GET";
+    }
+    delete _context.url;
+    const globalApi = new GlobalAPI(await this.getConfiguration());
+    return await globalApi.request(_context, initOverrides);
+  }
+};
+var GlobalAPI = class extends BaseAPI {
+  constructor(configuration) {
+    super(configuration);
+  }
+  request(context, initOverrides) {
+    return super.request(context, initOverrides);
+  }
 };
 export {
   AppStoreConnectAPI