@moonbase.sh/api 0.2.112 → 0.2.115

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(src_exports, {
   NotAuthenticatedError: () => NotAuthenticatedError,
   NotAuthorizedError: () => NotAuthorizedError,
   NotFoundError: () => NotFoundError,
+  OrderStatus: () => OrderStatus,
   ProductStatus: () => ProductStatus,
   TrialStatus: () => TrialStatus
 });
@@ -251,38 +252,61 @@ var CustomerEndpoints = class {
 
 // src/globalSchemas.ts
 var import_zod6 = require("zod");
+var userSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  email: import_zod6.z.string()
+});
+var entityChangeSchema = import_zod6.z.object({
+  at: import_zod6.z.coerce.date(),
+  by: userSchema
+});
+var moneySchema = import_zod6.z.object({
+  currency: import_zod6.z.string(),
+  amount: import_zod6.z.number()
+});
 var priceCollectionSchema = import_zod6.z.record(import_zod6.z.number());
 var percentageOffDiscountSchema = import_zod6.z.object({
   type: import_zod6.z.literal("PercentageOffDiscount"),
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().optional(),
-  percentage: import_zod6.z.number(),
-  total: priceCollectionSchema
+  percentage: import_zod6.z.number()
 });
 var flatAmountOffDiscountSchema = import_zod6.z.object({
   type: import_zod6.z.literal("FlatAmountOffDiscount"),
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().optional(),
   total: priceCollectionSchema
 });
 var discountSchema = import_zod6.z.discriminatedUnion("type", [
   percentageOffDiscountSchema,
   flatAmountOffDiscountSchema
 ]);
+var dateTimeSpanSchema = import_zod6.z.object({
+  from: import_zod6.z.coerce.date().nullable(),
+  to: import_zod6.z.coerce.date().nullable()
+});
+var pricingDiscountSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  description: import_zod6.z.string().nullable(),
+  discount: discountSchema,
+  applicableVariationIds: import_zod6.z.string().array().nullable(),
+  validity: dateTimeSpanSchema.nullable()
+});
 var pricingVariationSchema = import_zod6.z.object({
   id: import_zod6.z.string(),
   name: import_zod6.z.string(),
-  originalPrice: priceCollectionSchema,
-  price: priceCollectionSchema,
-  hasDiscount: import_zod6.z.boolean(),
-  discount: discountSchema.optional()
+  price: priceCollectionSchema
 });
-function paged(itemSchema) {
+function paged(itemSchema, api) {
   return import_zod6.z.object({
     items: import_zod6.z.array(itemSchema),
     hasMore: import_zod6.z.boolean(),
     next: import_zod6.z.string().nullable()
-  });
+  }).transform((page) => ({
+    ...page,
+    getNext: () => {
+      if (!page.hasMore || !page.next)
+        throw new Error("Response indicates no more results");
+      return api.fetch(page.next).then((response) => paged(itemSchema, api).parse(response.data));
+    }
+  }));
 }
 function quantifiable(itemSchema) {
   return import_zod6.z.object({
@@ -294,9 +318,6 @@ function quantifiable(itemSchema) {
 // src/utils/api.ts
 var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
-// src/utils/problemHandler.ts
-var import_zod7 = require("zod");
-
 // src/utils/errors.ts
 var MoonbaseError = class extends Error {
   constructor(problemDetails) {
@@ -337,6 +358,7 @@ var ConflictError = class extends MoonbaseError {
 };
 
 // src/utils/problemHandler.ts
+var import_zod7 = require("zod");
 var problemDetailsSchema = import_zod7.z.object({
   type: import_zod7.z.string(),
   title: import_zod7.z.string(),
@@ -386,6 +408,14 @@ var MoonbaseApi = class {
       },
       body: body ? contentType !== "application/json" ? body : JSON.stringify(body) : void 0
     });
+    if (response.status === 500) {
+      throw new MoonbaseError({
+        status: 500,
+        title: "Unknown error",
+        detail: "An unknown error occurred",
+        type: "InternalServerError"
+      });
+    }
     if (response.status >= 400)
       await handleResponseProblem(response);
     const contentLength = Number(response.headers.get("Content-Length")) || 0;
@@ -404,7 +434,7 @@ var LicenseEndpoints = class {
   }
   async query(opts) {
     const response = await this.api.fetch(`/api/licenses?${objectToQuery(opts)}`);
-    return paged(licenseSchema).parse(response.data);
+    return paged(licenseSchema, this.api).parse(response.data);
   }
   async get(licenseId) {
     const response = await this.api.fetch(`/api/licenses/${licenseId}`);
@@ -421,7 +451,7 @@ var LicenseEndpoints = class {
   }
   async queryActivations(licenseId, opts) {
     const response = await this.api.fetch(`/api/licenses/${licenseId}/activations?${objectToQuery(opts)}`);
-    return paged(licenseActivationSchema).parse(response.data);
+    return paged(licenseActivationSchema, this.api).parse(response.data);
   }
   async getActivation(licenseId, activationId) {
     const response = await this.api.fetch(`/api/licenses/${licenseId}/activations/${activationId}`);
@@ -437,6 +467,150 @@ var LicenseEndpoints = class {
   }
 };
 
+// src/orders/schemas.ts
+var import_zod8 = require("zod");
+
+// src/orders/models.ts
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["Open"] = "Open";
+  OrderStatus2["PaymentProcessing"] = "PaymentProcessing";
+  OrderStatus2["Completed"] = "Completed";
+  OrderStatus2["Failed"] = "Failed";
+  return OrderStatus2;
+})(OrderStatus || {});
+
+// src/orders/schemas.ts
+var couponSchema = import_zod8.z.object({
+  code: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  description: import_zod8.z.string()
+});
+var licenseLineItemFulfillmentSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("License"),
+  licenseIds: import_zod8.z.string().array()
+});
+var bundleLineItemFulfillmentSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("Bundle"),
+  productLicenses: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.object({
+    licenseIds: import_zod8.z.string().array()
+  }))
+});
+var lineItemFulfillmentSchema = import_zod8.z.discriminatedUnion("type", [
+  licenseLineItemFulfillmentSchema,
+  bundleLineItemFulfillmentSchema
+]);
+var lineItemTotalSchema = import_zod8.z.object({
+  original: moneySchema,
+  discount: moneySchema,
+  subtotal: moneySchema,
+  due: moneySchema
+});
+var lineItemPayoutSchema = import_zod8.z.object({
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  platformFees: moneySchema,
+  due: moneySchema
+});
+var affiliatePayoutSchema = import_zod8.z.object({
+  payout: moneySchema,
+  affiliateId: import_zod8.z.string(),
+  contractId: import_zod8.z.string()
+});
+var productLineItemSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("Product"),
+  productId: import_zod8.z.string(),
+  quantity: import_zod8.z.number(),
+  variationId: import_zod8.z.string(),
+  price: priceCollectionSchema.optional(),
+  total: lineItemTotalSchema.optional(),
+  payout: lineItemPayoutSchema.optional(),
+  affiliatePayouts: affiliatePayoutSchema.array().optional(),
+  variation: pricingVariationSchema.optional(),
+  appliedDiscount: pricingDiscountSchema.optional(),
+  fulfillment: lineItemFulfillmentSchema.optional()
+});
+var bundleLineItemSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("Bundle"),
+  bundleId: import_zod8.z.string(),
+  quantity: import_zod8.z.number(),
+  variationId: import_zod8.z.string(),
+  price: priceCollectionSchema.optional(),
+  total: lineItemTotalSchema.optional(),
+  payout: lineItemPayoutSchema.optional(),
+  affiliatePayouts: affiliatePayoutSchema.array().optional(),
+  variation: pricingVariationSchema.optional(),
+  appliedDiscount: pricingDiscountSchema.optional(),
+  fulfillment: lineItemFulfillmentSchema.optional()
+});
+var orderLineItemSchema = import_zod8.z.discriminatedUnion("type", [
+  productLineItemSchema,
+  bundleLineItemSchema
+]);
+var orderTotalSchema = import_zod8.z.object({
+  original: moneySchema,
+  discount: moneySchema,
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  due: moneySchema
+});
+var orderPayoutSchema = import_zod8.z.object({
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  platformFees: moneySchema,
+  due: moneySchema,
+  feeBreakdown: import_zod8.z.string().array()
+});
+var customerSnapshotSchema = import_zod8.z.object({
+  name: import_zod8.z.string().nullable(),
+  businessName: import_zod8.z.string().nullable(),
+  taxId: import_zod8.z.string().nullable(),
+  email: import_zod8.z.string().nullable(),
+  address: addressSchema.nullable()
+});
+var utmSchema = import_zod8.z.object({
+  referrer: import_zod8.z.string().optional(),
+  source: import_zod8.z.string().optional(),
+  medium: import_zod8.z.string().optional(),
+  campaign: import_zod8.z.string().optional(),
+  term: import_zod8.z.string().optional(),
+  content: import_zod8.z.string().optional()
+});
+var orderSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  status: import_zod8.z.nativeEnum(OrderStatus),
+  currency: import_zod8.z.string(),
+  completedAt: import_zod8.z.coerce.date().optional(),
+  isRefunded: import_zod8.z.boolean(),
+  refundedAt: import_zod8.z.coerce.date().optional(),
+  isDisputed: import_zod8.z.boolean(),
+  total: orderTotalSchema.optional(),
+  payout: orderPayoutSchema.optional(),
+  merchantPayout: moneySchema.optional(),
+  affiliatePayouts: affiliatePayoutSchema.array().optional(),
+  initialUTM: utmSchema.optional(),
+  currentUTM: utmSchema.optional(),
+  customer: customerSnapshotSchema.optional(),
+  couponsApplied: couponSchema.array(),
+  items: orderLineItemSchema.array(),
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
+});
+
+// src/orders/endpoints.ts
+var OrderEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async query(opts) {
+    const response = await this.api.fetch(`/api/orders?${objectToQuery(opts)}`);
+    return paged(orderSchema, this.api).parse(response.data);
+  }
+  async get(id) {
+    const response = await this.api.fetch(`/api/orders/${id}`);
+    return orderSchema.parse(response.data);
+  }
+};
+
 // src/products/endpoints.ts
 var ProductEndpoints = class {
   constructor(api) {
@@ -444,7 +618,7 @@ var ProductEndpoints = class {
   }
   async query(opts) {
     const response = await this.api.fetch(`/api/products?${objectToQuery(opts)}`);
-    return paged(productSchema).parse(response.data);
+    return paged(productSchema, this.api).parse(response.data);
   }
   async get(id) {
     const response = await this.api.fetch(`/api/products/${id}`);
@@ -469,34 +643,34 @@ var TrialEndpoints = class {
 };
 
 // src/vouchers/schemas.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/bundles/schemas.ts
-var import_zod8 = require("zod");
-var bundleSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  tagline: import_zod8.z.string(),
-  description: import_zod8.z.string(),
-  iconUrl: import_zod8.z.string().nullable(),
-  purchasable: import_zod8.z.boolean(),
-  partialPurchaseEnabled: import_zod8.z.boolean()
+var import_zod9 = require("zod");
+var bundleSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  tagline: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  iconUrl: import_zod9.z.string().nullable(),
+  purchasable: import_zod9.z.boolean(),
+  partialPurchaseEnabled: import_zod9.z.boolean()
 });
 
 // src/vouchers/schemas.ts
-var voucherSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  description: import_zod9.z.string(),
-  numberOfCodes: import_zod9.z.number(),
-  numberOfRedemptions: import_zod9.z.number(),
+var voucherSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  description: import_zod10.z.string(),
+  numberOfCodes: import_zod10.z.number(),
+  numberOfRedemptions: import_zod10.z.number(),
   redeemsProducts: quantifiable(productSchema).array(),
   redeemsBundles: quantifiable(bundleSchema).array()
 });
-var createVoucherRequestSchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  description: import_zod9.z.string(),
-  productEntitlements: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()).optional(),
-  bundleEntitlements: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()).optional()
+var createVoucherRequestSchema = import_zod10.z.object({
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string(),
+  productEntitlements: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.number()).optional(),
+  bundleEntitlements: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.number()).optional()
 });
 
 // src/vouchers/endpoints.ts
@@ -529,6 +703,7 @@ var MoonbaseClient = class {
     this.products = new ProductEndpoints(api);
     this.trials = new TrialEndpoints(api);
     this.vouchers = new VoucherEndpoints(api);
+    this.orders = new OrderEndpoints(api);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -543,6 +718,7 @@ var MoonbaseClient = class {
   NotAuthenticatedError,
   NotAuthorizedError,
   NotFoundError,
+  OrderStatus,
   ProductStatus,
   TrialStatus
 });