@moonbase.sh/storefront-api 0.2.34 → 0.2.35

package/dist/index.cjs

@@ -49,6 +49,44 @@ module.exports = __toCommonJS(src_exports);
 // src/activationRequests/endpoints.ts
 var import_zod5 = require("zod");
 
+// src/utils/errors.ts
+var NotAuthorizedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthorizedError";
+    this.message = "Not allowed";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthenticatedError";
+    this.message = "Not authenticated";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "NotFoundError";
+    this.message = message != null ? message : "Not found";
+  }
+};
+var MoonbaseError = class extends Error {
+  constructor(title, detail, status, errors) {
+    super();
+    this.title = title;
+    this.detail = detail;
+    this.status = status;
+    this.errors = errors;
+    this.name = "MoonbaseError";
+    if (errors && Object.values(errors).length === 1) {
+      this.message = Object.values(errors)[0];
+    } else {
+      this.message = detail != null ? detail : title;
+    }
+  }
+};
+
 // src/activationRequests/schemas.ts
 var import_zod4 = require("zod");
 
@@ -204,7 +242,12 @@ var ActivationRequestEndpoints = class {
   }
   async get(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}`);
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch activation request", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be fetched", response.status);
+    }
   }
   async isCompleted(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}/completed`);
@@ -212,15 +255,30 @@ var ActivationRequestEndpoints = class {
   }
   async fulfillLicense(requestId) {
     const response = await this.api.authenticatedFetch(`/api/customer/activations/${requestId}/license`, "POST");
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fulfill license", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be fulfilled", response.status);
+    }
   }
   async fulfillTrial(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}/trial`, "POST");
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fulfill trial", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be fulfilled", response.status);
+    }
   }
   async cancel(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}/cancel`, "POST");
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not cancel activation request", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be cancelled", response.status);
+    }
   }
 };
 
@@ -229,46 +287,6 @@ var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
 // src/utils/problemHandler.ts
 var import_zod6 = require("zod");
-
-// src/utils/errors.ts
-var NotAuthorizedError = class extends Error {
-  constructor() {
-    super();
-    this.name = "NotAuthorizedError";
-    this.message = "Not allowed";
-  }
-};
-var NotAuthenticatedError = class extends Error {
-  constructor() {
-    super();
-    this.name = "NotAuthenticatedError";
-    this.message = "Not authenticated";
-  }
-};
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super();
-    this.name = "NotFoundError";
-    this.message = message != null ? message : "Not found";
-  }
-};
-var MoonbaseError = class extends Error {
-  constructor(title, detail, status, errors) {
-    super();
-    this.title = title;
-    this.detail = detail;
-    this.status = status;
-    this.errors = errors;
-    this.name = "MoonbaseError";
-    if (errors && Object.values(errors).length === 1) {
-      this.message = Object.values(errors)[0];
-    } else {
-      this.message = detail != null ? detail : title;
-    }
-  }
-};
-
-// src/utils/problemHandler.ts
 var problemDetailsSchema = import_zod6.z.object({
   type: import_zod6.z.string(),
   title: import_zod6.z.string(),
@@ -349,7 +367,12 @@ var IdentityEndpoints = class {
   }
   async get() {
     const response = await this.api.authenticatedFetch("/api/customer/meta/user");
-    return userSchema.parse(response.data);
+    try {
+      return userSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch user", { response, err });
+      throw new MoonbaseError("Bad response", "Could not fetch user", response.status);
+    }
   }
   async signIn(email, password) {
     const response = await (0, import_cross_fetch.default)(`${this.api.baseUrl}/api/customer/identity/sign-in?email=${email}&scheme=JWT`, {
@@ -365,10 +388,15 @@ var IdentityEndpoints = class {
       throw new NotFoundError("User not found");
     if (response.status >= 400)
       await handleResponseProblem(response);
-    const data = await response.json();
-    const user = identityUserSchema.parse(data);
-    this.tokenStore.setUser(user);
-    return user;
+    try {
+      const data = await response.json();
+      const user = identityUserSchema.parse(data);
+      this.tokenStore.setUser(user);
+      return user;
+    } catch (err) {
+      console.error("Could not sign in user", { email, response, err });
+      throw new MoonbaseError("Bad response", "Could not sign in user", response.status);
+    }
   }
   async signUp(name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) {
     const response = await this.api.fetch(`/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`, "POST", {
@@ -379,9 +407,14 @@ var IdentityEndpoints = class {
       acceptedPrivacyPolicy,
       acceptedTermsAndConditions
     });
-    const user = identityUserSchema.parse(response.data);
-    this.tokenStore.setUser(user);
-    return user;
+    try {
+      const user = identityUserSchema.parse(response.data);
+      this.tokenStore.setUser(user);
+      return user;
+    } catch (err) {
+      console.error("Could not sign up user", { email, response, err });
+      throw new MoonbaseError("Bad response", "Could not sign up user", response.status);
+    }
   }
   async update(name, email, emailConfirmationToken, communicationPreferences) {
     const response = await this.api.authenticatedFetch("/api/customer/identity", "PATCH", {
@@ -418,7 +451,12 @@ var IdentityEndpoints = class {
   }
   async confirmAccount(email, code) {
     const response = await this.api.fetch(`/api/customer/identity/confirm-account?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
-    return userAccountConfirmedSchema.parse(response.data);
+    try {
+      return userAccountConfirmedSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not confirm user account", { email, code, response, err });
+      throw new MoonbaseError("Bad response", "Could not confirm user account", response.status);
+    }
   }
   async confirmEmail(email, code) {
     await this.api.fetch(`/api/customer/identity/confirm-email?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
@@ -563,7 +601,12 @@ var OrderEndpoints = class {
         items: order.items
       }
     );
-    return openOrderSchema.parse(response.data);
+    try {
+      return openOrderSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch order", { orderId: order.id, checkout, response, err });
+      throw new MoonbaseError("Bad response", "Could not fetch order", response.status);
+    }
   }
 };
 
@@ -590,7 +633,12 @@ var StorefrontEndpoints = class {
   async get(utm) {
     const query = new URLSearchParams(utmToObject(utm));
     const response = await this.api.fetch(`/api/customer/storefront?${query.toString()}`);
-    return storefrontSchema.parse(response.data);
+    try {
+      return storefrontSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch storefront", { response, err });
+      throw new MoonbaseError("Bad response", "Could not fetch storefront", response.status);
+    }
   }
 };
 
@@ -624,12 +672,25 @@ var MoonbaseApi = class {
     });
     if (response.status >= 400)
       await handleResponseProblem(response);
-    const contentLength = Number(response.headers.get("Content-Length")) || 0;
-    return {
-      data: contentLength > 0 ? await response.json() : null,
-      headers: response.headers,
-      status: response.status
-    };
+    try {
+      const contentLength = Number(response.headers.get("Content-Length")) || 0;
+      const data = contentLength > 0 ? await response.json() : null;
+      return {
+        data,
+        headers: response.headers,
+        status: response.status
+      };
+    } catch (err) {
+      console.error("Could not parse response", {
+        status: response.status,
+        content: await response.text(),
+        contentType: response.headers.get("Content-Type"),
+        contentLength: response.headers.get("Content-Length"),
+        userAgent: window && window.navigator && window.navigator.userAgent,
+        err
+      });
+      throw new MoonbaseError("Bad response", "Could not parse server response", response.status);
+    }
   }
 };
 
@@ -764,7 +825,12 @@ var VoucherEndpoints = class {
       `/api/customer/vouchers/redeem?code=${encodeURIComponent(code)}`,
       "POST"
     );
-    return voucherSchema.parse(response.data);
+    try {
+      return voucherSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not redeem voucher", { response, err });
+      throw new MoonbaseError("Bad response", "Could not redeem voucher", response.status);
+    }
   }
 };
 
@@ -816,10 +882,15 @@ var ActivationEndpoints = class {
   }
   async activate(deviceToken, activationMethod) {
     const response = await this.api.authenticatedFetch(`/api/customer/inventory/activate?method=${activationMethod}`, "POST", deviceToken, "text/plain");
-    return {
-      license: licenseSchema.parse(response.data),
-      url: import_zod11.z.string().parse(response.headers.get("location"))
-    };
+    try {
+      return {
+        license: licenseSchema.parse(response.data),
+        url: import_zod11.z.string().parse(response.headers.get("location"))
+      };
+    } catch (err) {
+      console.error("Could not activate product", { deviceToken, activationMethod, response, err });
+      throw new MoonbaseError("Bad response", "Product could not be activated", response.status);
+    }
   }
 };
 
@@ -830,13 +901,23 @@ var LicenseEndpoints = class {
   }
   async get(nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/licenses");
-    return paged(licenseSchema).parse(response.data);
+    try {
+      return paged(licenseSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch licenses", { nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Licenses could not be fetched", response.status);
+    }
   }
   async getActivations(licenseId, nextUrl) {
     const response = await this.api.authenticatedFetch(
       nextUrl || `/api/customer/inventory/licenses/${licenseId}/activations`
     );
-    return paged(activationSchema).parse(response.data);
+    try {
+      return paged(activationSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch license activations", { nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "License activations could not be fetched", response.status);
+    }
   }
   async revokeActivation(licenseId, activationId) {
     await this.api.authenticatedFetch(`/api/customer/inventory/licenses/${licenseId}/activations/${activationId}/revoke`, "POST");
@@ -851,19 +932,39 @@ var ProductEndpoints = class {
   }
   async get(productId, version) {
     const response = await this.api.fetch(`/api/customer/inventory/products/${productId}${version ? `?version=${version}` : ""}`);
-    return productSummarySchema.parse(response.data);
+    try {
+      return productSummarySchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch product", { productId, version, response, err });
+      throw new MoonbaseError("Bad response", "Product could not be fetched", response.status);
+    }
   }
   async getOwned(nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/products");
-    return paged(productSummarySchema).parse(response.data);
+    try {
+      return paged(productSummarySchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch products", { nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Products could not be fetched", response.status);
+    }
   }
   async getLicenses(productId, nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses`);
-    return paged(licenseSchema).parse(response.data);
+    try {
+      return paged(licenseSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch product licenses", { productId, nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Product licenses could not be fetched", response.status);
+    }
   }
   async getActivations(productId, nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses/activations`);
-    return paged(activationSchema).parse(response.data);
+    try {
+      return paged(activationSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch product activations", { productId, nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Product activations could not be fetched", response.status);
+    }
   }
   async getDownloadUrl(path) {
     const url = new URL(path);

package/dist/index.d.cts

@@ -10725,9 +10725,9 @@ declare class NotFoundError extends Error {
 declare class MoonbaseError extends Error {
     readonly title: string;
     readonly detail: string | undefined;
-    readonly status: number;
+    readonly status?: number | undefined;
     readonly errors?: Record<string, string> | undefined;
-    constructor(title: string, detail: string | undefined, status: number, errors?: Record<string, string> | undefined);
+    constructor(title: string, detail: string | undefined, status?: number | undefined, errors?: Record<string, string> | undefined);
 }
 
 declare namespace schemas {

package/dist/index.d.ts

@@ -10725,9 +10725,9 @@ declare class NotFoundError extends Error {
 declare class MoonbaseError extends Error {
     readonly title: string;
     readonly detail: string | undefined;
-    readonly status: number;
+    readonly status?: number | undefined;
     readonly errors?: Record<string, string> | undefined;
-    constructor(title: string, detail: string | undefined, status: number, errors?: Record<string, string> | undefined);
+    constructor(title: string, detail: string | undefined, status?: number | undefined, errors?: Record<string, string> | undefined);
 }
 
 declare namespace schemas {

package/dist/index.js

@@ -7,6 +7,44 @@ var __export = (target, all) => {
 // src/activationRequests/endpoints.ts
 import { z as z5 } from "zod";
 
+// src/utils/errors.ts
+var NotAuthorizedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthorizedError";
+    this.message = "Not allowed";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthenticatedError";
+    this.message = "Not authenticated";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "NotFoundError";
+    this.message = message != null ? message : "Not found";
+  }
+};
+var MoonbaseError = class extends Error {
+  constructor(title, detail, status, errors) {
+    super();
+    this.title = title;
+    this.detail = detail;
+    this.status = status;
+    this.errors = errors;
+    this.name = "MoonbaseError";
+    if (errors && Object.values(errors).length === 1) {
+      this.message = Object.values(errors)[0];
+    } else {
+      this.message = detail != null ? detail : title;
+    }
+  }
+};
+
 // src/activationRequests/schemas.ts
 import { z as z4 } from "zod";
 
@@ -162,7 +200,12 @@ var ActivationRequestEndpoints = class {
   }
   async get(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}`);
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch activation request", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be fetched", response.status);
+    }
   }
   async isCompleted(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}/completed`);
@@ -170,15 +213,30 @@ var ActivationRequestEndpoints = class {
   }
   async fulfillLicense(requestId) {
     const response = await this.api.authenticatedFetch(`/api/customer/activations/${requestId}/license`, "POST");
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fulfill license", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be fulfilled", response.status);
+    }
   }
   async fulfillTrial(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}/trial`, "POST");
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fulfill trial", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be fulfilled", response.status);
+    }
   }
   async cancel(requestId) {
     const response = await this.api.fetch(`/api/customer/activations/${requestId}/cancel`, "POST");
-    return activationRequestSchema.parse(response.data);
+    try {
+      return activationRequestSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not cancel activation request", { requestId, response, err });
+      throw new MoonbaseError("Bad response", "Activation request could not be cancelled", response.status);
+    }
   }
 };
 
@@ -187,46 +245,6 @@ import fetch from "cross-fetch";
 
 // src/utils/problemHandler.ts
 import { z as z6 } from "zod";
-
-// src/utils/errors.ts
-var NotAuthorizedError = class extends Error {
-  constructor() {
-    super();
-    this.name = "NotAuthorizedError";
-    this.message = "Not allowed";
-  }
-};
-var NotAuthenticatedError = class extends Error {
-  constructor() {
-    super();
-    this.name = "NotAuthenticatedError";
-    this.message = "Not authenticated";
-  }
-};
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super();
-    this.name = "NotFoundError";
-    this.message = message != null ? message : "Not found";
-  }
-};
-var MoonbaseError = class extends Error {
-  constructor(title, detail, status, errors) {
-    super();
-    this.title = title;
-    this.detail = detail;
-    this.status = status;
-    this.errors = errors;
-    this.name = "MoonbaseError";
-    if (errors && Object.values(errors).length === 1) {
-      this.message = Object.values(errors)[0];
-    } else {
-      this.message = detail != null ? detail : title;
-    }
-  }
-};
-
-// src/utils/problemHandler.ts
 var problemDetailsSchema = z6.object({
   type: z6.string(),
   title: z6.string(),
@@ -307,7 +325,12 @@ var IdentityEndpoints = class {
   }
   async get() {
     const response = await this.api.authenticatedFetch("/api/customer/meta/user");
-    return userSchema.parse(response.data);
+    try {
+      return userSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch user", { response, err });
+      throw new MoonbaseError("Bad response", "Could not fetch user", response.status);
+    }
   }
   async signIn(email, password) {
     const response = await fetch(`${this.api.baseUrl}/api/customer/identity/sign-in?email=${email}&scheme=JWT`, {
@@ -323,10 +346,15 @@ var IdentityEndpoints = class {
       throw new NotFoundError("User not found");
     if (response.status >= 400)
       await handleResponseProblem(response);
-    const data = await response.json();
-    const user = identityUserSchema.parse(data);
-    this.tokenStore.setUser(user);
-    return user;
+    try {
+      const data = await response.json();
+      const user = identityUserSchema.parse(data);
+      this.tokenStore.setUser(user);
+      return user;
+    } catch (err) {
+      console.error("Could not sign in user", { email, response, err });
+      throw new MoonbaseError("Bad response", "Could not sign in user", response.status);
+    }
   }
   async signUp(name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) {
     const response = await this.api.fetch(`/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`, "POST", {
@@ -337,9 +365,14 @@ var IdentityEndpoints = class {
       acceptedPrivacyPolicy,
       acceptedTermsAndConditions
     });
-    const user = identityUserSchema.parse(response.data);
-    this.tokenStore.setUser(user);
-    return user;
+    try {
+      const user = identityUserSchema.parse(response.data);
+      this.tokenStore.setUser(user);
+      return user;
+    } catch (err) {
+      console.error("Could not sign up user", { email, response, err });
+      throw new MoonbaseError("Bad response", "Could not sign up user", response.status);
+    }
   }
   async update(name, email, emailConfirmationToken, communicationPreferences) {
     const response = await this.api.authenticatedFetch("/api/customer/identity", "PATCH", {
@@ -376,7 +409,12 @@ var IdentityEndpoints = class {
   }
   async confirmAccount(email, code) {
     const response = await this.api.fetch(`/api/customer/identity/confirm-account?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
-    return userAccountConfirmedSchema.parse(response.data);
+    try {
+      return userAccountConfirmedSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not confirm user account", { email, code, response, err });
+      throw new MoonbaseError("Bad response", "Could not confirm user account", response.status);
+    }
   }
   async confirmEmail(email, code) {
     await this.api.fetch(`/api/customer/identity/confirm-email?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
@@ -521,7 +559,12 @@ var OrderEndpoints = class {
         items: order.items
       }
     );
-    return openOrderSchema.parse(response.data);
+    try {
+      return openOrderSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch order", { orderId: order.id, checkout, response, err });
+      throw new MoonbaseError("Bad response", "Could not fetch order", response.status);
+    }
   }
 };
 
@@ -548,7 +591,12 @@ var StorefrontEndpoints = class {
   async get(utm) {
     const query = new URLSearchParams(utmToObject(utm));
     const response = await this.api.fetch(`/api/customer/storefront?${query.toString()}`);
-    return storefrontSchema.parse(response.data);
+    try {
+      return storefrontSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch storefront", { response, err });
+      throw new MoonbaseError("Bad response", "Could not fetch storefront", response.status);
+    }
   }
 };
 
@@ -582,12 +630,25 @@ var MoonbaseApi = class {
     });
     if (response.status >= 400)
       await handleResponseProblem(response);
-    const contentLength = Number(response.headers.get("Content-Length")) || 0;
-    return {
-      data: contentLength > 0 ? await response.json() : null,
-      headers: response.headers,
-      status: response.status
-    };
+    try {
+      const contentLength = Number(response.headers.get("Content-Length")) || 0;
+      const data = contentLength > 0 ? await response.json() : null;
+      return {
+        data,
+        headers: response.headers,
+        status: response.status
+      };
+    } catch (err) {
+      console.error("Could not parse response", {
+        status: response.status,
+        content: await response.text(),
+        contentType: response.headers.get("Content-Type"),
+        contentLength: response.headers.get("Content-Length"),
+        userAgent: window && window.navigator && window.navigator.userAgent,
+        err
+      });
+      throw new MoonbaseError("Bad response", "Could not parse server response", response.status);
+    }
   }
 };
 
@@ -722,7 +783,12 @@ var VoucherEndpoints = class {
       `/api/customer/vouchers/redeem?code=${encodeURIComponent(code)}`,
       "POST"
     );
-    return voucherSchema.parse(response.data);
+    try {
+      return voucherSchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not redeem voucher", { response, err });
+      throw new MoonbaseError("Bad response", "Could not redeem voucher", response.status);
+    }
   }
 };
 
@@ -774,10 +840,15 @@ var ActivationEndpoints = class {
   }
   async activate(deviceToken, activationMethod) {
     const response = await this.api.authenticatedFetch(`/api/customer/inventory/activate?method=${activationMethod}`, "POST", deviceToken, "text/plain");
-    return {
-      license: licenseSchema.parse(response.data),
-      url: z11.string().parse(response.headers.get("location"))
-    };
+    try {
+      return {
+        license: licenseSchema.parse(response.data),
+        url: z11.string().parse(response.headers.get("location"))
+      };
+    } catch (err) {
+      console.error("Could not activate product", { deviceToken, activationMethod, response, err });
+      throw new MoonbaseError("Bad response", "Product could not be activated", response.status);
+    }
   }
 };
 
@@ -788,13 +859,23 @@ var LicenseEndpoints = class {
   }
   async get(nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/licenses");
-    return paged(licenseSchema).parse(response.data);
+    try {
+      return paged(licenseSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch licenses", { nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Licenses could not be fetched", response.status);
+    }
   }
   async getActivations(licenseId, nextUrl) {
     const response = await this.api.authenticatedFetch(
       nextUrl || `/api/customer/inventory/licenses/${licenseId}/activations`
     );
-    return paged(activationSchema).parse(response.data);
+    try {
+      return paged(activationSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch license activations", { nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "License activations could not be fetched", response.status);
+    }
   }
   async revokeActivation(licenseId, activationId) {
     await this.api.authenticatedFetch(`/api/customer/inventory/licenses/${licenseId}/activations/${activationId}/revoke`, "POST");
@@ -809,19 +890,39 @@ var ProductEndpoints = class {
   }
   async get(productId, version) {
     const response = await this.api.fetch(`/api/customer/inventory/products/${productId}${version ? `?version=${version}` : ""}`);
-    return productSummarySchema.parse(response.data);
+    try {
+      return productSummarySchema.parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch product", { productId, version, response, err });
+      throw new MoonbaseError("Bad response", "Product could not be fetched", response.status);
+    }
   }
   async getOwned(nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/products");
-    return paged(productSummarySchema).parse(response.data);
+    try {
+      return paged(productSummarySchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch products", { nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Products could not be fetched", response.status);
+    }
   }
   async getLicenses(productId, nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses`);
-    return paged(licenseSchema).parse(response.data);
+    try {
+      return paged(licenseSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch product licenses", { productId, nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Product licenses could not be fetched", response.status);
+    }
   }
   async getActivations(productId, nextUrl) {
     const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses/activations`);
-    return paged(activationSchema).parse(response.data);
+    try {
+      return paged(activationSchema).parse(response.data);
+    } catch (err) {
+      console.error("Could not fetch product activations", { productId, nextUrl, response, err });
+      throw new MoonbaseError("Bad response", "Product activations could not be fetched", response.status);
+    }
   }
   async getDownloadUrl(path) {
     const url = new URL(path);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonbase.sh/storefront-api",
   "type": "module",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "description": "Package to let you build storefronts with Moonbase.sh as payment and delivery provider",
   "author": "Tobias Lønnerød Madsen <m@dsen.tv>",
   "license": "MIT",