@moonbase.sh/storefront-api 0.1.94 → 0.1.97

package/dist/index.cjs

@@ -40,7 +40,8 @@ __export(src_exports, {
   NotAuthorizedError: () => NotAuthorizedError,
   NotFoundError: () => NotFoundError,
   OrderStatus: () => OrderStatus,
-  Platform: () => Platform
+  Platform: () => Platform,
+  utmToObject: () => utmToObject
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -95,10 +96,10 @@ function quantifiable(itemSchema) {
   });
 }
 
-// src/products/schemas.ts
+// src/inventory/products/schemas.ts
 var import_zod2 = require("zod");
 
-// src/products/models.ts
+// src/inventory/products/models.ts
 var Platform = /* @__PURE__ */ ((Platform2) => {
   Platform2["Universal"] = "Universal";
   Platform2["Windows"] = "Windows";
@@ -107,7 +108,7 @@ var Platform = /* @__PURE__ */ ((Platform2) => {
   return Platform2;
 })(Platform || {});
 
-// src/products/schemas.ts
+// src/inventory/products/schemas.ts
 var downloadSchema = import_zod2.z.object({
   name: import_zod2.z.string(),
   key: import_zod2.z.string(),
@@ -152,7 +153,7 @@ var storefrontBundleSchema = import_zod3.z.object({
   owned: import_zod3.z.boolean(),
   partial: import_zod3.z.boolean(),
   products: storefrontProductSchema.and(import_zod3.z.object({
-    included: import_zod3.z.boolean()
+    included: import_zod3.z.boolean().optional()
   })).array(),
   defaultVariation: pricingVariationSchema.optional(),
   variations: pricingVariationSchema.array().optional(),
@@ -374,66 +375,8 @@ var IdentityEndpoints = class {
   }
 };
 
-// src/licenses/schemas.ts
-var import_zod8 = require("zod");
-
-// src/licenses/models.ts
-var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
-  LicenseStatus2["Active"] = "Active";
-  LicenseStatus2["Revoked"] = "Revoked";
-  return LicenseStatus2;
-})(LicenseStatus || {});
-var ActivationStatus = /* @__PURE__ */ ((ActivationStatus2) => {
-  ActivationStatus2["Active"] = "Active";
-  ActivationStatus2["Revoked"] = "Revoked";
-  return ActivationStatus2;
-})(ActivationStatus || {});
-var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
-  ActivationMethod2["Online"] = "Online";
-  ActivationMethod2["Offline"] = "Offline";
-  return ActivationMethod2;
-})(ActivationMethod || {});
-
-// src/licenses/schemas.ts
-var licenseSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  status: import_zod8.z.nativeEnum(LicenseStatus),
-  product: productSummarySchema.optional(),
-  activeNumberOfActivations: import_zod8.z.number(),
-  maxNumberOfActivations: import_zod8.z.number(),
-  createdAt: import_zod8.z.coerce.date()
-});
-var activationSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  licenseId: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  status: import_zod8.z.nativeEnum(ActivationStatus),
-  activationMethod: import_zod8.z.nativeEnum(ActivationMethod),
-  lastValidatedAt: import_zod8.z.coerce.date().nullable()
-});
-
-// src/licenses/endpoints.ts
-var LicenseEndpoints = class {
-  constructor(api) {
-    this.api = api;
-  }
-  async get(nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/licenses");
-    return paged(licenseSchema).parse(response.data);
-  }
-  async getActivations(licenseId, nextUrl) {
-    const response = await this.api.authenticatedFetch(
-      nextUrl || `/api/customer/licenses/${licenseId}/activations`
-    );
-    return paged(activationSchema).parse(response.data);
-  }
-  async revokeActivation(licenseId, activationId) {
-    await this.api.authenticatedFetch(`/api/customer/licenses/${licenseId}/activations/${activationId}/revoke`, "POST");
-  }
-};
-
 // src/orders/schemas.ts
-var import_zod9 = require("zod");
+var import_zod8 = require("zod");
 
 // src/orders/models.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
@@ -447,65 +390,65 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = import_zod9.z.object({
-  code: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  description: import_zod9.z.string()
+var couponSchema = import_zod8.z.object({
+  code: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  description: import_zod8.z.string()
 });
-var percentageOffDiscountSchema2 = import_zod9.z.object({
-  type: import_zod9.z.literal("PercentageOffDiscount"),
-  name: import_zod9.z.string(),
-  description: import_zod9.z.string().optional(),
-  percentage: import_zod9.z.number(),
+var percentageOffDiscountSchema2 = import_zod8.z.object({
+  type: import_zod8.z.literal("PercentageOffDiscount"),
+  name: import_zod8.z.string(),
+  description: import_zod8.z.string().optional(),
+  percentage: import_zod8.z.number(),
   total: priceCollectionSchema.optional(),
-  isExclusive: import_zod9.z.boolean()
+  isExclusive: import_zod8.z.boolean()
 });
-var flatAmountOffDiscountSchema2 = import_zod9.z.object({
-  type: import_zod9.z.literal("FlatAmountOffDiscount"),
-  name: import_zod9.z.string(),
-  description: import_zod9.z.string().optional(),
+var flatAmountOffDiscountSchema2 = import_zod8.z.object({
+  type: import_zod8.z.literal("FlatAmountOffDiscount"),
+  name: import_zod8.z.string(),
+  description: import_zod8.z.string().optional(),
   total: priceCollectionSchema.optional(),
-  isExclusive: import_zod9.z.boolean()
+  isExclusive: import_zod8.z.boolean()
 });
-var discountSchema2 = import_zod9.z.discriminatedUnion("type", [
+var discountSchema2 = import_zod8.z.discriminatedUnion("type", [
   percentageOffDiscountSchema2,
   flatAmountOffDiscountSchema2
 ]);
-var openProductLineItem = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  type: import_zod9.z.literal("Product"),
-  productId: import_zod9.z.string(),
-  quantity: import_zod9.z.number(),
-  variationId: import_zod9.z.string(),
+var openProductLineItem = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  type: import_zod8.z.literal("Product"),
+  productId: import_zod8.z.string(),
+  quantity: import_zod8.z.number(),
+  variationId: import_zod8.z.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   product: storefrontProductSchema.optional(),
   appliedDiscount: discountSchema2.optional()
 });
-var openBundleLineItem = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  type: import_zod9.z.literal("Bundle"),
-  bundleId: import_zod9.z.string(),
-  quantity: import_zod9.z.number(),
-  variationId: import_zod9.z.string(),
+var openBundleLineItem = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  type: import_zod8.z.literal("Bundle"),
+  bundleId: import_zod8.z.string(),
+  quantity: import_zod8.z.number(),
+  variationId: import_zod8.z.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   bundle: storefrontBundleSchema.optional(),
   appliedDiscount: discountSchema2.optional()
 });
-var openOrderLineItem = import_zod9.z.discriminatedUnion("type", [
+var openOrderLineItem = import_zod8.z.discriminatedUnion("type", [
   openProductLineItem,
   openBundleLineItem
 ]);
-var openOrderSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  status: import_zod9.z.literal("Open" /* Open */),
-  currency: import_zod9.z.string(),
+var openOrderSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  status: import_zod8.z.literal("Open" /* Open */),
+  currency: import_zod8.z.string(),
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array(),
-  checkoutUrl: import_zod9.z.string().optional()
+  checkoutUrl: import_zod8.z.string().optional()
 });
-var orderSchema = import_zod9.z.discriminatedUnion("status", [
+var orderSchema = import_zod8.z.discriminatedUnion("status", [
   openOrderSchema
 ]);
 
@@ -518,9 +461,16 @@ var OrderEndpoints = class {
     const response = await this.api.fetch(`/api/customer/orders/${orderId}`);
     return orderSchema.parse(response.data);
   }
-  async pushContent(order, checkout) {
+  async pushContent(order, checkout, utm) {
+    const query = {
+      ...utmToObject(utm)
+    };
+    if (checkout) {
+      query.checkout = "true";
+      query.returnUrl = checkout.returnUrl;
+    }
     const response = await this.api.fetch(
-      `/api/customer/orders/${order.id}${checkout ? `?checkout=true&returnUrl=${encodeURIComponent(checkout.returnUrl)}` : ""}`,
+      `/api/customer/orders/${order.id}?${new URLSearchParams(query).toString()}`,
       "PATCH",
       {
         currency: order.currency,
@@ -531,40 +481,29 @@ var OrderEndpoints = class {
   }
 };
 
-// src/products/endpoints.ts
-var import_zod10 = require("zod");
-var ProductEndpoints = class {
-  constructor(api) {
-    this.api = api;
-  }
-  async getOwned(nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/products");
-    return paged(productSummarySchema).parse(response.data);
-  }
-  async getLicenses(productId, nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/products/${productId}/licenses`);
-    return paged(licenseSchema).parse(response.data);
-  }
-  async getActivations(productId, nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/products/${productId}/licenses/activations`);
-    return paged(activationSchema).parse(response.data);
-  }
-  async activate(deviceToken, activationMethod) {
-    const response = await this.api.authenticatedFetch(`/api/customer/products/activate?method=${activationMethod}`, "POST", deviceToken, "text/plain");
-    return {
-      license: licenseSchema.parse(response.data),
-      url: import_zod10.z.string().parse(response.headers.get("location"))
-    };
-  }
-};
+// src/globalModels.ts
+function utmToObject(utm) {
+  return Object.entries({
+    utm_source: utm == null ? void 0 : utm.source,
+    utm_medium: utm == null ? void 0 : utm.medium,
+    utm_campaign: utm == null ? void 0 : utm.campaign,
+    utm_term: utm == null ? void 0 : utm.term,
+    utm_content: utm == null ? void 0 : utm.content,
+    utm_referrer: utm == null ? void 0 : utm.referrer
+  }).filter(([_, value]) => value !== void 0).reduce((obj, [key, value]) => ({
+    ...obj,
+    [key]: value
+  }), {});
+}
 
 // src/storefront/endpoints.ts
 var StorefrontEndpoints = class {
   constructor(api) {
     this.api = api;
   }
-  async get() {
-    const response = await this.api.fetch("/api/customer/storefront");
+  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);
   }
 };
@@ -707,13 +646,13 @@ _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
 
 // src/vouchers/schemas.ts
-var import_zod11 = require("zod");
-var voucherSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string(),
-  code: import_zod11.z.string(),
-  redeemed: import_zod11.z.boolean(),
+var import_zod9 = require("zod");
+var voucherSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  code: import_zod9.z.string(),
+  redeemed: import_zod9.z.boolean(),
   redeemsProducts: quantifiable(storefrontProductSchema).array(),
   redeemsBundles: quantifiable(storefrontBundleSchema).array()
 });
@@ -736,6 +675,119 @@ var VoucherEndpoints = class {
   }
 };
 
+// src/inventory/activation/endpoints.ts
+var import_zod11 = require("zod");
+
+// src/inventory/licenses/schemas.ts
+var import_zod10 = require("zod");
+
+// src/inventory/licenses/models.ts
+var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
+  LicenseStatus2["Active"] = "Active";
+  LicenseStatus2["Revoked"] = "Revoked";
+  return LicenseStatus2;
+})(LicenseStatus || {});
+var ActivationStatus = /* @__PURE__ */ ((ActivationStatus2) => {
+  ActivationStatus2["Active"] = "Active";
+  ActivationStatus2["Revoked"] = "Revoked";
+  return ActivationStatus2;
+})(ActivationStatus || {});
+var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
+  ActivationMethod2["Online"] = "Online";
+  ActivationMethod2["Offline"] = "Offline";
+  return ActivationMethod2;
+})(ActivationMethod || {});
+
+// src/inventory/licenses/schemas.ts
+var licenseSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  status: import_zod10.z.nativeEnum(LicenseStatus),
+  product: productSummarySchema,
+  activeNumberOfActivations: import_zod10.z.number(),
+  maxNumberOfActivations: import_zod10.z.number(),
+  createdAt: import_zod10.z.coerce.date()
+});
+var activationSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  licenseId: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  status: import_zod10.z.nativeEnum(ActivationStatus),
+  activationMethod: import_zod10.z.nativeEnum(ActivationMethod),
+  lastValidatedAt: import_zod10.z.coerce.date().nullable()
+});
+
+// src/inventory/activation/endpoints.ts
+var ActivationEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  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"))
+    };
+  }
+};
+
+// src/inventory/licenses/endpoints.ts
+var LicenseEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/licenses");
+    return paged(licenseSchema).parse(response.data);
+  }
+  async getActivations(licenseId, nextUrl) {
+    const response = await this.api.authenticatedFetch(
+      nextUrl || `/api/customer/inventory/licenses/${licenseId}/activations`
+    );
+    return paged(activationSchema).parse(response.data);
+  }
+  async revokeActivation(licenseId, activationId) {
+    await this.api.authenticatedFetch(`/api/customer/inventory/licenses/${licenseId}/activations/${activationId}/revoke`, "POST");
+  }
+};
+
+// src/inventory/products/endpoints.ts
+var import_zod12 = require("zod");
+var ProductEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async getOwned(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/products");
+    return paged(productSummarySchema).parse(response.data);
+  }
+  async getLicenses(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses`);
+    return paged(licenseSchema).parse(response.data);
+  }
+  async getActivations(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses/activations`);
+    return paged(activationSchema).parse(response.data);
+  }
+  async getDownloadUrl(path) {
+    const url = new URL(path);
+    url.searchParams.append("redirect", "false");
+    const response = await this.api.authenticatedFetch(url.pathname + url.search);
+    const content = import_zod12.z.object({
+      location: import_zod12.z.string()
+    }).parse(response.data);
+    return content.location;
+  }
+};
+
+// src/inventory/index.ts
+var InventoryEndpoints = class {
+  constructor(api) {
+    this.licenses = new LicenseEndpoints(api);
+    this.products = new ProductEndpoints(api);
+    this.activation = new ActivationEndpoints(api);
+  }
+};
+
 // src/index.ts
 var MoonbaseClient = class {
   constructor(configuration) {
@@ -747,9 +799,8 @@ var MoonbaseClient = class {
     this.identity = new IdentityEndpoints(api, this.tokenStore);
     this.vouchers = new VoucherEndpoints(api);
     this.orders = new OrderEndpoints(api);
-    this.licenses = new LicenseEndpoints(api);
+    this.inventory = new InventoryEndpoints(api);
     this.activationRequests = new ActivationRequestEndpoints(api);
-    this.products = new ProductEndpoints(api);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -764,5 +815,6 @@ var MoonbaseClient = class {
   NotAuthorizedError,
   NotFoundError,
   OrderStatus,
-  Platform
+  Platform,
+  utmToObject
 });