appstore-connect-sdk 1.2.0 → 1.3.0

package/README.md

@@ -86,7 +86,7 @@ import { AppStoreConnectAPI } from "appstore-connect-sdk";
 import {
   AppsApi,
   AppEventLocalizationsApi,
-} from "appstore-connect-sdk/dist/openapi/apis";
+} from "appstore-connect-sdk/openapi";
 
 const client = new AppStoreConnectAPI({
   issuerId: "<YOUR ISSUER ID>",

package/dist/cjs/main.js

@@ -83,6 +83,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("&");
 }
@@ -943,11 +1072,12 @@ async function generateAuthToken({ apiKeyId, issuerId, privateKey, expirationTim
     kid: apiKeyId,
     // The type of the token (JWT)
     typ: "JWT"
-  }).setIssuer(issuerId).setAudience("appstoreconnect-v1").setExpirationTime(expirationTime ?? (/* @__PURE__ */ new Date()).getTime() / 1e3).sign(key);
+  }).setIssuer(issuerId).setAudience("appstoreconnect-v1").setExpirationTime(expirationTime).sign(key);
   return token;
 }
 
 // src/main.ts
+var DEFAULT_EXPIRATION_DURATION_SECONDS = 60 * 20;
 var AppStoreConnectAPI = class {
   /**
    * Creates an instance of the AppStoreConnectAPI.
@@ -957,13 +1087,15 @@ var AppStoreConnectAPI = class {
    * @param options.privateKey - The content of the private key used for generating JWT token.
    * @param options.fetchApi - (Optional) The FetchAPI implementation to use for API requests.
    * @param options.bearerToken - (Optional) A pre-generated bearer token to use for authentication.
-   * @param options.expirationTime - (Optional) The time (in seconds) until the token expires (default 10 minutes)
+   * @param options.expirationDuration - (Optional) The expiration duration for the bearer token in seconds (default 20 minutes).
    * @param options.basePath - (Optional) The base path for the API (without trailing slash, default https://api.appstoreconnect.apple.com).
    * @throws {string} Will throw an error if no bearerToken or private key is provided
    */
   constructor(options) {
+    /**
+     * The time (in milliseconds) when the current bearer token was generated.
+     */
     this.bearerTokenGeneratedAt = 0;
-    if (options.expirationTime) options.expirationTime = options.expirationTime;
     this.options = options;
   }
   /**
@@ -972,16 +1104,16 @@ var AppStoreConnectAPI = class {
   async genToken() {
     if (this.options.bearerToken) {
       return this.options.bearerToken;
-    } else if (this.options.privateKeyId && this.options.issuerId && this.options.privateKey) {
+    }
+    if (this.options.privateKeyId && this.options.issuerId && this.options.privateKey) {
       return await generateAuthToken({
         apiKeyId: this.options.privateKeyId,
         issuerId: this.options.issuerId,
         privateKey: this.options.privateKey,
-        expirationTime: this.options.expirationTime
+        expirationTime: Math.floor(Date.now() / 1e3) + (this.options.expirationDuration ?? DEFAULT_EXPIRATION_DURATION_SECONDS)
       });
-    } else {
-      throw "No bearerToken!!!";
     }
+    throw "No bearerToken or private key provided";
   }
   /**
    * Create a Configuration object with the authentication token and any provided FetchAPI implementation.
@@ -1000,7 +1132,9 @@ var AppStoreConnectAPI = class {
    * Returns the current bearer token, generating a new one if necessary.
    */
   async getConfiguration() {
-    const hasExpired = this.bearerTokenGeneratedAt && Date.now() - this.bearerTokenGeneratedAt > 1e3 * this.options.expirationTime;
+    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) {
       await this.genConfiguration();
     }
@@ -1014,6 +1148,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);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {