@moonbase.sh/storefront-api 0.3.3 → 0.3.5

package/dist/index.cjs

@@ -43,7 +43,9 @@ __export(index_exports, {
   NotFoundError: () => NotFoundError,
   OrderStatus: () => OrderStatus,
   Platform: () => Platform,
-  schemas: () => schemas_exports2,
+  SubscriptionStatus: () => SubscriptionStatus,
+  TokenStore: () => TokenStore,
+  schemas: () => schemas_exports3,
   utmToObject: () => utmToObject
 });
 module.exports = __toCommonJS(index_exports);
@@ -100,6 +102,10 @@ var flatAmountOffDiscountSchema = import_zod.z.object({
   total: priceCollectionSchema.optional(),
   isExclusive: import_zod.z.boolean()
 });
+var moneySchema = import_zod.z.object({
+  currency: import_zod.z.string(),
+  amount: import_zod.z.number()
+});
 var discountSchema = import_zod.z.discriminatedUnion("type", [
   percentageOffDiscountSchema,
   flatAmountOffDiscountSchema
@@ -120,8 +126,7 @@ var pricingVariationSchema = import_zod.z.object({
   price: priceCollectionSchema,
   hasDiscount: import_zod.z.boolean(),
   discount: discountSchema.optional(),
-  // TODO: Remove default once subscriptions are live
-  recurrence: recurrenceSchema.default({ type: "OneOff" }),
+  recurrence: recurrenceSchema,
   pricingTiers: import_zod.z.array(pricingTierSchema).nullish()
 });
 function paged(itemSchema) {
@@ -178,6 +183,7 @@ var productSummarySchema = import_zod2.z.object({
   currentActivations: import_zod2.z.number().optional(),
   maxActivations: import_zod2.z.number().optional(),
   externalLicenses: import_zod2.z.number().optional(),
+  subscriptionLicenses: import_zod2.z.number().optional(),
   currentVersion: import_zod2.z.string().nullable(),
   version: import_zod2.z.string().optional(),
   prerelease: import_zod2.z.boolean().optional(),
@@ -364,6 +370,14 @@ async function handleResponseProblem(response) {
 }
 
 // src/identity/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  addressSchema: () => addressSchema,
+  communicationPreferencesSchema: () => communicationPreferencesSchema,
+  identityUserSchema: () => identityUserSchema,
+  userAccountConfirmedSchema: () => userAccountConfirmedSchema,
+  userSchema: () => userSchema
+});
 var import_zod7 = require("zod");
 var addressSchema = import_zod7.z.object({
   countryCode: import_zod7.z.string(),
@@ -384,7 +398,10 @@ var userSchema = import_zod7.z.object({
   tenantId: import_zod7.z.string(),
   address: addressSchema.optional(),
   communicationPreferences: communicationPreferencesSchema,
-  ownedProducts: import_zod7.z.string().array().optional()
+  ownedProducts: import_zod7.z.string().array().optional(),
+  subscribedProducts: import_zod7.z.string().array().optional(),
+  hasProducts: import_zod7.z.boolean().nullish(),
+  hasSubscriptions: import_zod7.z.boolean().nullish()
 });
 var identityUserSchema = userSchema.and(import_zod7.z.object({
   accessToken: import_zod7.z.string(),
@@ -533,6 +550,7 @@ var licenseSchema = import_zod8.z.object({
   activeNumberOfActivations: import_zod8.z.number(),
   maxNumberOfActivations: import_zod8.z.number(),
   externalFulfillment: import_zod8.z.string().optional(),
+  expiresAt: import_zod8.z.coerce.date().optional(),
   createdAt: import_zod8.z.coerce.date()
 });
 var activationSchema = import_zod8.z.object({
@@ -619,24 +637,30 @@ var ProductEndpoints = class {
   }
 };
 
-// src/inventory/index.ts
-var InventoryEndpoints = class {
-  constructor(api, configuration) {
-    this.licenses = new LicenseEndpoints(api, configuration);
-    this.products = new ProductEndpoints(api, configuration);
-    this.activation = new ActivationEndpoints(api, configuration);
-  }
-};
+// src/inventory/subscriptions/endpoints.ts
+var import_zod13 = require("zod");
+
+// src/inventory/subscriptions/schemas.ts
+var import_zod12 = require("zod");
+
+// src/inventory/subscriptions/models.ts
+var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
+  SubscriptionStatus2["Active"] = "Active";
+  SubscriptionStatus2["Expired"] = "Expired";
+  SubscriptionStatus2["Cancelled"] = "Cancelled";
+  return SubscriptionStatus2;
+})(SubscriptionStatus || {});
 
 // src/orders/schemas.ts
-var schemas_exports = {};
-__export(schemas_exports, {
+var schemas_exports2 = {};
+__export(schemas_exports2, {
   completedOrderSchema: () => completedOrderSchema,
   openBundleLineItem: () => openBundleLineItem,
   openOrderLineItem: () => openOrderLineItem,
   openOrderSchema: () => openOrderSchema,
   openProductLineItem: () => openProductLineItem,
-  orderSchema: () => orderSchema
+  orderSchema: () => orderSchema,
+  orderTotalSchema: () => orderTotalSchema
 });
 var import_zod11 = require("zod");
 
@@ -710,10 +734,6 @@ var openOrderSchema = import_zod11.z.object({
   checkoutUrl: import_zod11.z.string().optional(),
   embeddedCheckoutUrl: import_zod11.z.string().optional()
 });
-var moneySchema = import_zod11.z.object({
-  currency: import_zod11.z.string(),
-  amount: import_zod11.z.number()
-});
 var orderTotalSchema = import_zod11.z.object({
   original: moneySchema,
   discount: moneySchema,
@@ -753,6 +773,66 @@ var orderSchema = import_zod11.z.discriminatedUnion("status", [
   completedOrderSchema
 ]);
 
+// src/inventory/subscriptions/schemas.ts
+var subscriptionSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  status: import_zod12.z.nativeEnum(SubscriptionStatus),
+  hasPaymentMethod: import_zod12.z.boolean(),
+  expiresAt: import_zod12.z.coerce.date(),
+  renewedAt: import_zod12.z.coerce.date().nullable(),
+  startedAt: import_zod12.z.coerce.date(),
+  total: orderTotalSchema,
+  cycleLength: import_zod12.z.nativeEnum(CycleLength),
+  content: import_zod12.z.discriminatedUnion("type", [
+    import_zod12.z.object({
+      type: import_zod12.z.literal("Product"),
+      quantity: import_zod12.z.number(),
+      product: storefrontProductSchema
+    }),
+    import_zod12.z.object({
+      type: import_zod12.z.literal("Bundle"),
+      quantity: import_zod12.z.number(),
+      bundle: storefrontBundleSchema
+    })
+  ])
+});
+
+// src/inventory/subscriptions/endpoints.ts
+var SubscriptionEndpoints = class {
+  constructor(api, configuration) {
+    this.api = api;
+    this.configuration = configuration;
+  }
+  async get(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/subscriptions", paged(subscriptionSchema));
+    return response.data;
+  }
+  async getById(subscriptionId) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}`, subscriptionSchema);
+    return response.data;
+  }
+  async cancel(subscriptionId) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}/cancel`, subscriptionSchema, { method: "POST" });
+    return response.data;
+  }
+  async renew(subscriptionId, returnUrl, embedded) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}/renew?redirect=false&return=${returnUrl}&embedded=${embedded ? "true" : "false"}`, import_zod13.z.object({
+      location: import_zod13.z.string()
+    }), { method: "POST" });
+    return response.data;
+  }
+};
+
+// src/inventory/index.ts
+var InventoryEndpoints = class {
+  constructor(api, configuration) {
+    this.licenses = new LicenseEndpoints(api, configuration);
+    this.products = new ProductEndpoints(api, configuration);
+    this.activation = new ActivationEndpoints(api, configuration);
+    this.subscriptions = new SubscriptionEndpoints(api, configuration);
+  }
+};
+
 // src/orders/endpoints.ts
 var OrderEndpoints = class {
   constructor(api) {
@@ -835,7 +915,8 @@ var MoonbaseApi = class {
         "x-mb-cors": "1"
       },
       body: (options == null ? void 0 : options.body) ? contentType !== "application/json" ? options.body : JSON.stringify(options.body) : void 0,
-      signal: options == null ? void 0 : options.abort
+      signal: options == null ? void 0 : options.abort,
+      redirect: "manual"
     });
     if (response.status >= 400)
       await handleResponseProblem(response);
@@ -964,11 +1045,11 @@ _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
 
 // src/vendor/schemas.ts
-var import_zod12 = require("zod");
-var vendorSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  logoUrl: import_zod12.z.string().nullable()
+var import_zod14 = require("zod");
+var vendorSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  name: import_zod14.z.string(),
+  logoUrl: import_zod14.z.string().nullable()
 });
 
 // src/vendor/endpoints.ts
@@ -983,13 +1064,13 @@ var VendorEndpoints = class {
 };
 
 // src/vouchers/schemas.ts
-var import_zod13 = require("zod");
-var voucherSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  description: import_zod13.z.string(),
-  code: import_zod13.z.string(),
-  redeemed: import_zod13.z.boolean(),
+var import_zod15 = require("zod");
+var voucherSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  name: import_zod15.z.string(),
+  description: import_zod15.z.string(),
+  code: import_zod15.z.string(),
+  redeemed: import_zod15.z.boolean(),
   redeemsProducts: quantifiable(storefrontProductSchema).array(),
   redeemsBundles: quantifiable(storefrontBundleSchema).array()
 });
@@ -1016,9 +1097,10 @@ var VoucherEndpoints = class {
 };
 
 // src/schemas.ts
-var schemas_exports2 = {};
-__export(schemas_exports2, {
-  orders: () => schemas_exports
+var schemas_exports3 = {};
+__export(schemas_exports3, {
+  identity: () => schemas_exports,
+  orders: () => schemas_exports2
 });
 
 // src/index.ts
@@ -1052,6 +1134,8 @@ var MoonbaseClient = class {
   NotFoundError,
   OrderStatus,
   Platform,
+  SubscriptionStatus,
+  TokenStore,
   schemas,
   utmToObject
 });