@moonbase.sh/api 0.2.112 → 0.2.115

package/dist/index.js

@@ -204,38 +204,61 @@ var CustomerEndpoints = class {
 
 // src/globalSchemas.ts
 import { z as z6 } from "zod";
+var userSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  email: z6.string()
+});
+var entityChangeSchema = z6.object({
+  at: z6.coerce.date(),
+  by: userSchema
+});
+var moneySchema = z6.object({
+  currency: z6.string(),
+  amount: z6.number()
+});
 var priceCollectionSchema = z6.record(z6.number());
 var percentageOffDiscountSchema = z6.object({
   type: z6.literal("PercentageOffDiscount"),
-  name: z6.string(),
-  description: z6.string().optional(),
-  percentage: z6.number(),
-  total: priceCollectionSchema
+  percentage: z6.number()
 });
 var flatAmountOffDiscountSchema = z6.object({
   type: z6.literal("FlatAmountOffDiscount"),
-  name: z6.string(),
-  description: z6.string().optional(),
   total: priceCollectionSchema
 });
 var discountSchema = z6.discriminatedUnion("type", [
   percentageOffDiscountSchema,
   flatAmountOffDiscountSchema
 ]);
+var dateTimeSpanSchema = z6.object({
+  from: z6.coerce.date().nullable(),
+  to: z6.coerce.date().nullable()
+});
+var pricingDiscountSchema = z6.object({
+  name: z6.string(),
+  description: z6.string().nullable(),
+  discount: discountSchema,
+  applicableVariationIds: z6.string().array().nullable(),
+  validity: dateTimeSpanSchema.nullable()
+});
 var pricingVariationSchema = z6.object({
   id: z6.string(),
   name: z6.string(),
-  originalPrice: priceCollectionSchema,
-  price: priceCollectionSchema,
-  hasDiscount: z6.boolean(),
-  discount: discountSchema.optional()
+  price: priceCollectionSchema
 });
-function paged(itemSchema) {
+function paged(itemSchema, api) {
   return z6.object({
     items: z6.array(itemSchema),
     hasMore: z6.boolean(),
     next: z6.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 z6.object({
@@ -247,9 +270,6 @@ function quantifiable(itemSchema) {
 // src/utils/api.ts
 import fetch from "cross-fetch";
 
-// src/utils/problemHandler.ts
-import { z as z7 } from "zod";
-
 // src/utils/errors.ts
 var MoonbaseError = class extends Error {
   constructor(problemDetails) {
@@ -290,6 +310,7 @@ var ConflictError = class extends MoonbaseError {
 };
 
 // src/utils/problemHandler.ts
+import { z as z7 } from "zod";
 var problemDetailsSchema = z7.object({
   type: z7.string(),
   title: z7.string(),
@@ -339,6 +360,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;
@@ -357,7 +386,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}`);
@@ -374,7 +403,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}`);
@@ -390,6 +419,150 @@ var LicenseEndpoints = class {
   }
 };
 
+// src/orders/schemas.ts
+import { z as z8 } from "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 = z8.object({
+  code: z8.string(),
+  name: z8.string(),
+  description: z8.string()
+});
+var licenseLineItemFulfillmentSchema = z8.object({
+  type: z8.literal("License"),
+  licenseIds: z8.string().array()
+});
+var bundleLineItemFulfillmentSchema = z8.object({
+  type: z8.literal("Bundle"),
+  productLicenses: z8.record(z8.string(), z8.object({
+    licenseIds: z8.string().array()
+  }))
+});
+var lineItemFulfillmentSchema = z8.discriminatedUnion("type", [
+  licenseLineItemFulfillmentSchema,
+  bundleLineItemFulfillmentSchema
+]);
+var lineItemTotalSchema = z8.object({
+  original: moneySchema,
+  discount: moneySchema,
+  subtotal: moneySchema,
+  due: moneySchema
+});
+var lineItemPayoutSchema = z8.object({
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  platformFees: moneySchema,
+  due: moneySchema
+});
+var affiliatePayoutSchema = z8.object({
+  payout: moneySchema,
+  affiliateId: z8.string(),
+  contractId: z8.string()
+});
+var productLineItemSchema = z8.object({
+  type: z8.literal("Product"),
+  productId: z8.string(),
+  quantity: z8.number(),
+  variationId: z8.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 = z8.object({
+  type: z8.literal("Bundle"),
+  bundleId: z8.string(),
+  quantity: z8.number(),
+  variationId: z8.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 = z8.discriminatedUnion("type", [
+  productLineItemSchema,
+  bundleLineItemSchema
+]);
+var orderTotalSchema = z8.object({
+  original: moneySchema,
+  discount: moneySchema,
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  due: moneySchema
+});
+var orderPayoutSchema = z8.object({
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  platformFees: moneySchema,
+  due: moneySchema,
+  feeBreakdown: z8.string().array()
+});
+var customerSnapshotSchema = z8.object({
+  name: z8.string().nullable(),
+  businessName: z8.string().nullable(),
+  taxId: z8.string().nullable(),
+  email: z8.string().nullable(),
+  address: addressSchema.nullable()
+});
+var utmSchema = z8.object({
+  referrer: z8.string().optional(),
+  source: z8.string().optional(),
+  medium: z8.string().optional(),
+  campaign: z8.string().optional(),
+  term: z8.string().optional(),
+  content: z8.string().optional()
+});
+var orderSchema = z8.object({
+  id: z8.string(),
+  status: z8.nativeEnum(OrderStatus),
+  currency: z8.string(),
+  completedAt: z8.coerce.date().optional(),
+  isRefunded: z8.boolean(),
+  refundedAt: z8.coerce.date().optional(),
+  isDisputed: z8.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) {
@@ -397,7 +570,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}`);
@@ -422,34 +595,34 @@ var TrialEndpoints = class {
 };
 
 // src/vouchers/schemas.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/bundles/schemas.ts
-import { z as z8 } from "zod";
-var bundleSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
-  tagline: z8.string(),
-  description: z8.string(),
-  iconUrl: z8.string().nullable(),
-  purchasable: z8.boolean(),
-  partialPurchaseEnabled: z8.boolean()
+import { z as z9 } from "zod";
+var bundleSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  tagline: z9.string(),
+  description: z9.string(),
+  iconUrl: z9.string().nullable(),
+  purchasable: z9.boolean(),
+  partialPurchaseEnabled: z9.boolean()
 });
 
 // src/vouchers/schemas.ts
-var voucherSchema = z9.object({
-  id: z9.string(),
-  description: z9.string(),
-  numberOfCodes: z9.number(),
-  numberOfRedemptions: z9.number(),
+var voucherSchema = z10.object({
+  id: z10.string(),
+  description: z10.string(),
+  numberOfCodes: z10.number(),
+  numberOfRedemptions: z10.number(),
   redeemsProducts: quantifiable(productSchema).array(),
   redeemsBundles: quantifiable(bundleSchema).array()
 });
-var createVoucherRequestSchema = z9.object({
-  name: z9.string(),
-  description: z9.string(),
-  productEntitlements: z9.record(z9.string(), z9.number()).optional(),
-  bundleEntitlements: z9.record(z9.string(), z9.number()).optional()
+var createVoucherRequestSchema = z10.object({
+  name: z10.string(),
+  description: z10.string(),
+  productEntitlements: z10.record(z10.string(), z10.number()).optional(),
+  bundleEntitlements: z10.record(z10.string(), z10.number()).optional()
 });
 
 // src/vouchers/endpoints.ts
@@ -482,6 +655,7 @@ var MoonbaseClient = class {
     this.products = new ProductEndpoints(api);
     this.trials = new TrialEndpoints(api);
     this.vouchers = new VoucherEndpoints(api);
+    this.orders = new OrderEndpoints(api);
   }
 };
 export {
@@ -495,6 +669,7 @@ export {
   NotAuthenticatedError,
   NotAuthorizedError,
   NotFoundError,
+  OrderStatus,
   ProductStatus,
   TrialStatus
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moonbase.sh/api",
   "type": "module",
-  "version": "0.2.112",
+  "version": "0.2.115",
   "description": "Package to let you integrate backends with Moonbase.sh as payment and delivery provider",
   "author": "Tobias Lønnerød Madsen <m@dsen.tv>",
   "license": "MIT",
@@ -20,11 +20,13 @@
     "@types/node": "^18.19.50",
     "rimraf": "^5.0.10",
     "tsup": "^7.1.0",
-    "typescript": "~5.1.6"
+    "typescript": "~5.1.6",
+    "vitest": "^2.1.4"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",
     "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
-    "version": "npm version"
+    "version": "npm version",
+    "test": "vitest"
   }
 }