@gpc-cli/api 1.0.5 → 1.0.7

package/dist/index.js

@@ -1,7 +1,3 @@
-// src/http.ts
-import { readFile } from "fs/promises";
-import { resolve, isAbsolute } from "path";
-
 // src/errors.ts
 var ApiError = class extends Error {
   constructor(message, code, statusCode, suggestion) {
@@ -25,6 +21,8 @@ var ApiError = class extends Error {
 };
 
 // src/http.ts
+import { readFile } from "fs/promises";
+import { resolve, isAbsolute } from "path";
 function sanitizeErrorBody(body) {
   try {
     const parsed = JSON.parse(body);
@@ -52,6 +50,7 @@ function validateFilePath(filePath) {
 }
 var BASE_URL = "https://androidpublisher.googleapis.com/androidpublisher/v3/applications";
 var UPLOAD_BASE_URL = "https://androidpublisher.googleapis.com/upload/androidpublisher/v3/applications";
+var INTERNAL_SHARING_UPLOAD_BASE_URL = "https://androidpublisher.googleapis.com/upload/internalappsharing/v3/applications";
 function envInt(name) {
   const val = process.env[name];
   if (val === void 0) return void 0;
@@ -227,8 +226,8 @@ function createHttpClient(options) {
     }
     throw lastError ?? new ApiError("Request failed", "API_NETWORK_ERROR");
   }
-  async function uploadRequest(path, filePath, contentType) {
-    const url = `${UPLOAD_BASE_URL}${path}`;
+  async function uploadRequest(path, filePath, contentType, baseUrl = UPLOAD_BASE_URL) {
+    const url = `${baseUrl}${path}`;
     const safeFilePath = validateFilePath(filePath);
     const fileBuffer = await readFile(safeFilePath);
     let token = await options.auth.getAccessToken();
@@ -355,6 +354,40 @@ function createHttpClient(options) {
     },
     upload(path, filePath, contentType) {
       return uploadRequest(path, filePath, contentType);
+    },
+    uploadInternal(path, filePath, contentType) {
+      return uploadRequest(path, filePath, contentType, INTERNAL_SHARING_UPLOAD_BASE_URL);
+    },
+    async download(path) {
+      const url = `${options.baseUrl ?? BASE_URL}${path}`;
+      const token = await options.auth.getAccessToken();
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Accept-Encoding": "gzip, deflate",
+            Connection: "keep-alive"
+          },
+          signal: controller.signal,
+          keepalive: true
+        });
+        if (!response.ok) {
+          const errorBody = await response.text();
+          const { code, suggestion } = mapStatusToError(response.status, errorBody);
+          throw new ApiError(
+            `GET ${path} failed with status ${response.status}: ${sanitizeErrorBody(errorBody)}`,
+            code,
+            response.status,
+            suggestion
+          );
+        }
+        return await response.arrayBuffer();
+      } finally {
+        clearTimeout(timer);
+      }
     }
   };
 }
@@ -422,7 +455,12 @@ function createApiClient(options) {
           "application/octet-stream"
         );
         if (!data.bundle) {
-          throw new Error("Upload succeeded but no bundle data returned");
+          throw new ApiError(
+            "Upload succeeded but no bundle data returned",
+            "API_EMPTY_RESPONSE",
+            200,
+            "This is unexpected. Retry the upload or contact Google Play support if the issue persists."
+          );
         }
         return data.bundle;
       }
@@ -494,7 +532,12 @@ function createApiClient(options) {
           filePath.endsWith(".png") ? "image/png" : "image/jpeg"
         );
         if (!data.image) {
-          throw new Error("Upload succeeded but no image data returned");
+          throw new ApiError(
+            "Upload succeeded but no image data returned",
+            "API_EMPTY_RESPONSE",
+            200,
+            "This is unexpected. Retry the upload or contact Google Play support if the issue persists."
+          );
         }
         return data.image;
       },
@@ -518,6 +561,21 @@ function createApiClient(options) {
         return data;
       }
     },
+    dataSafety: {
+      async get(packageName, editId) {
+        const { data } = await http.get(
+          `/${packageName}/edits/${editId}/dataSafety`
+        );
+        return data;
+      },
+      async update(packageName, editId, body) {
+        const { data } = await http.put(
+          `/${packageName}/edits/${editId}/dataSafety`,
+          body
+        );
+        return data;
+      }
+    },
     reviews: {
       async list(packageName, options2) {
         await rateLimit(limiter, "reviewsGet");
@@ -792,10 +850,177 @@ function createApiClient(options) {
           "application/octet-stream"
         );
         if (!data.deobfuscationFile) {
-          throw new Error("Upload succeeded but no deobfuscation file data returned");
+          throw new ApiError(
+            "Upload succeeded but no deobfuscation file data returned",
+            "API_EMPTY_RESPONSE",
+            200,
+            "This is unexpected. Retry the upload or contact Google Play support if the issue persists."
+          );
         }
         return data.deobfuscationFile;
       }
+    },
+    appRecovery: {
+      async list(packageName) {
+        const { data } = await http.post(
+          `/${packageName}/appRecoveries`
+        );
+        return data.recoveryActions || [];
+      },
+      async cancel(packageName, appRecoveryId) {
+        await http.post(`/${packageName}/appRecovery/${appRecoveryId}:cancel`);
+      },
+      async deploy(packageName, appRecoveryId) {
+        await http.post(`/${packageName}/appRecovery/${appRecoveryId}:deploy`);
+      },
+      async create(packageName, request) {
+        const { data } = await http.post(
+          `/${packageName}/appRecoveries`,
+          request
+        );
+        return data;
+      },
+      async addTargeting(packageName, appRecoveryId, targeting) {
+        const { data } = await http.post(
+          `/${packageName}/appRecoveries/${appRecoveryId}:addTargeting`,
+          targeting
+        );
+        return data;
+      }
+    },
+    externalTransactions: {
+      async create(packageName, body) {
+        const { data } = await http.post(
+          `/${packageName}/externalTransactions`,
+          body
+        );
+        return data;
+      },
+      async get(packageName, transactionId) {
+        const { data } = await http.get(
+          `/${packageName}/externalTransactions/${transactionId}`
+        );
+        return data;
+      },
+      async refund(packageName, transactionId, refundData) {
+        const { data } = await http.post(
+          `/${packageName}/externalTransactions/${transactionId}:refund`,
+          refundData
+        );
+        return data;
+      }
+    },
+    deviceTiers: {
+      async list(packageName) {
+        const { data } = await http.get(
+          `/${packageName}/deviceTierConfigs`
+        );
+        return data.deviceTierConfigs || [];
+      },
+      async get(packageName, configId) {
+        const { data } = await http.get(
+          `/${packageName}/deviceTierConfigs/${configId}`
+        );
+        return data;
+      },
+      async create(packageName, config) {
+        const { data } = await http.post(
+          `/${packageName}/deviceTierConfigs`,
+          config
+        );
+        return data;
+      }
+    },
+    oneTimeProducts: {
+      async list(packageName) {
+        const { data } = await http.get(
+          `/${packageName}/oneTimeProducts`
+        );
+        return data;
+      },
+      async get(packageName, productId) {
+        const { data } = await http.get(
+          `/${packageName}/oneTimeProducts/${productId}`
+        );
+        return data;
+      },
+      async create(packageName, body) {
+        const { data } = await http.post(
+          `/${packageName}/oneTimeProducts`,
+          body
+        );
+        return data;
+      },
+      async update(packageName, productId, body) {
+        const { data } = await http.patch(
+          `/${packageName}/oneTimeProducts/${productId}`,
+          body
+        );
+        return data;
+      },
+      async delete(packageName, productId) {
+        await http.delete(`/${packageName}/oneTimeProducts/${productId}`);
+      },
+      async listOffers(packageName, productId) {
+        const { data } = await http.get(
+          `/${packageName}/oneTimeProducts/${productId}/offers`
+        );
+        return data;
+      },
+      async getOffer(packageName, productId, offerId) {
+        const { data } = await http.get(
+          `/${packageName}/oneTimeProducts/${productId}/offers/${offerId}`
+        );
+        return data;
+      },
+      async createOffer(packageName, productId, body) {
+        const { data } = await http.post(
+          `/${packageName}/oneTimeProducts/${productId}/offers`,
+          body
+        );
+        return data;
+      },
+      async updateOffer(packageName, productId, offerId, body) {
+        const { data } = await http.patch(
+          `/${packageName}/oneTimeProducts/${productId}/offers/${offerId}`,
+          body
+        );
+        return data;
+      },
+      async deleteOffer(packageName, productId, offerId) {
+        await http.delete(`/${packageName}/oneTimeProducts/${productId}/offers/${offerId}`);
+      }
+    },
+    internalAppSharing: {
+      async uploadBundle(packageName, bundlePath) {
+        const { data } = await http.uploadInternal(
+          `/${packageName}/artifacts/bundle`,
+          bundlePath,
+          "application/octet-stream"
+        );
+        return data;
+      },
+      async uploadApk(packageName, apkPath) {
+        const { data } = await http.uploadInternal(
+          `/${packageName}/artifacts/apk`,
+          apkPath,
+          "application/vnd.android.package-archive"
+        );
+        return data;
+      }
+    },
+    generatedApks: {
+      async list(packageName, versionCode) {
+        const { data } = await http.get(
+          `/${packageName}/generatedApks/${versionCode}`
+        );
+        return data.generatedApks || [];
+      },
+      async download(packageName, versionCode, id) {
+        return http.download(
+          `/${packageName}/generatedApks/${versionCode}/download/${id}`
+        );
+      }
     }
   };
 }