@moonbase.sh/api 0.1.109

package/dist/index.cjs

@@ -0,0 +1,393 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ActivationMethod: () => ActivationMethod,
+  ActivationRequestStatus: () => ActivationRequestStatus,
+  ActivationStatus: () => ActivationStatus,
+  LicenseStatus: () => LicenseStatus,
+  MoonbaseClient: () => MoonbaseClient,
+  MoonbaseError: () => MoonbaseError,
+  NotAuthenticatedError: () => NotAuthenticatedError,
+  NotAuthorizedError: () => NotAuthorizedError,
+  NotFoundError: () => NotFoundError,
+  ProductStatus: () => ProductStatus,
+  TrialStatus: () => TrialStatus
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/activationRequests/schemas.ts
+var import_zod5 = require("zod");
+
+// src/customers/schemas.ts
+var import_zod = require("zod");
+var addressSchema = import_zod.z.object({
+  countryCode: import_zod.z.string(),
+  streetAddress1: import_zod.z.string(),
+  streetAddress2: import_zod.z.string().nullable(),
+  locality: import_zod.z.string().nullable(),
+  region: import_zod.z.string().nullable(),
+  postCode: import_zod.z.string()
+});
+var communicationPreferencesSchema = import_zod.z.object({
+  newsletterOptIn: import_zod.z.boolean()
+  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+});
+var customerSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  businessName: import_zod.z.string().nullable(),
+  taxId: import_zod.z.string().nullable(),
+  email: import_zod.z.string(),
+  numberOfLicenses: import_zod.z.number(),
+  numberOfTrials: import_zod.z.number(),
+  emailConfirmed: import_zod.z.boolean(),
+  hasPassword: import_zod.z.boolean(),
+  isDeleted: import_zod.z.boolean(),
+  ownedProducts: import_zod.z.string().array(),
+  address: addressSchema.nullable(),
+  communicationPreferences: communicationPreferencesSchema
+});
+
+// src/licenses/schemas.ts
+var import_zod2 = 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_zod2.z.object({
+  id: import_zod2.z.string(),
+  status: import_zod2.z.nativeEnum(LicenseStatus),
+  activeNumberOfActivations: import_zod2.z.number(),
+  maxNumberOfActivations: import_zod2.z.number()
+});
+var licenseActivationSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  status: import_zod2.z.nativeEnum(ActivationStatus),
+  activationMethod: import_zod2.z.nativeEnum(ActivationMethod),
+  lastValidatedAt: import_zod2.z.coerce.date(),
+  license: licenseSchema
+});
+
+// src/products/schemas.ts
+var import_zod3 = require("zod");
+
+// src/products/models.ts
+var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
+  ProductStatus2["Active"] = "Active";
+  ProductStatus2["Inactive"] = "Inactive";
+  return ProductStatus2;
+})(ProductStatus || {});
+
+// src/products/schemas.ts
+var productSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  tagline: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  website: import_zod3.z.string().nullable(),
+  iconUrl: import_zod3.z.string().nullable(),
+  status: import_zod3.z.nativeEnum(ProductStatus),
+  purchasable: import_zod3.z.boolean(),
+  currentReleaseVersion: import_zod3.z.string().nullable()
+});
+
+// src/trials/schemas.ts
+var import_zod4 = require("zod");
+
+// src/trials/models.ts
+var TrialStatus = /* @__PURE__ */ ((TrialStatus2) => {
+  TrialStatus2["Active"] = "Active";
+  TrialStatus2["Expired"] = "Expired";
+  return TrialStatus2;
+})(TrialStatus || {});
+
+// src/trials/schemas.ts
+var trialSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  status: import_zod4.z.nativeEnum(TrialStatus),
+  expiresAt: import_zod4.z.coerce.date(),
+  lastValidatedAt: import_zod4.z.coerce.date(),
+  ownerId: import_zod4.z.string().optional()
+});
+
+// src/activationRequests/models.ts
+var ActivationRequestStatus = /* @__PURE__ */ ((ActivationRequestStatus2) => {
+  ActivationRequestStatus2["Requested"] = "Requested";
+  ActivationRequestStatus2["Fulfilled"] = "Fulfilled";
+  ActivationRequestStatus2["Completed"] = "Completed";
+  return ActivationRequestStatus2;
+})(ActivationRequestStatus || {});
+
+// src/activationRequests/schemas.ts
+var activationRequestSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  status: import_zod5.z.nativeEnum(ActivationRequestStatus),
+  product: productSchema,
+  activation: licenseActivationSchema.optional(),
+  trial: trialSchema.optional(),
+  customer: customerSchema.optional()
+});
+
+// src/activationRequests/endpoints.ts
+var ActivationRequestEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(requestId) {
+    const response = await this.api.fetch(`/api/activations/${requestId}`);
+    return activationRequestSchema.parse(response.data);
+  }
+  async request(productId) {
+    const response = await this.api.fetch(`/api/activations/${productId}/request`);
+    return activationRequestSchema.parse(response.data);
+  }
+};
+
+// src/customers/endpoints.ts
+var CustomerEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(idOrEmail) {
+    const response = await this.api.fetch(`/api/customers/${idOrEmail}`);
+    return customerSchema.parse(response.data);
+  }
+};
+
+// src/licenses/endpoints.ts
+var LicenseEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async validate(licenseId, activationId) {
+    const response = await this.api.fetch(`/api/licenses/${licenseId}/activations/${activationId}/validate`, "POST");
+    return licenseActivationSchema.parse(response.data);
+  }
+};
+
+// src/globalSchemas.ts
+var import_zod6 = require("zod");
+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
+});
+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 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()
+});
+function paged(itemSchema) {
+  return import_zod6.z.object({
+    items: import_zod6.z.array(itemSchema),
+    hasMore: import_zod6.z.boolean(),
+    next: import_zod6.z.string().nullable()
+  });
+}
+
+// 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 NotAuthorizedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthorizedError";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthenticatedError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotFoundError";
+  }
+};
+var MoonbaseError = class extends Error {
+  constructor(title, detail, status) {
+    super();
+    this.title = title;
+    this.detail = detail;
+    this.status = status;
+    this.name = "MoonbaseError";
+    this.message = detail != null ? detail : title;
+  }
+};
+
+// src/utils/problemHandler.ts
+var problemDetailsSchema = import_zod7.z.object({
+  type: import_zod7.z.string(),
+  title: import_zod7.z.string(),
+  detail: import_zod7.z.string().optional(),
+  status: import_zod7.z.number()
+});
+async function handleResponseProblem(response) {
+  if (response.status === 404)
+    throw new NotFoundError();
+  if (response.status === 401)
+    throw new NotAuthenticatedError();
+  if (response.status === 403)
+    throw new NotAuthorizedError();
+  let problemDetails;
+  try {
+    const json = await response.json();
+    problemDetails = problemDetailsSchema.parse(json);
+  } catch (e) {
+    throw new Error("An unknown problem occurred");
+  }
+  throw new MoonbaseError(problemDetails.title, problemDetails.detail, problemDetails.status);
+}
+
+// src/utils/api.ts
+function objectToQuery(obj) {
+  return Object.entries(obj != null ? obj : {}).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+}
+var MoonbaseApi = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  async fetch(path, method, body, contentType) {
+    contentType != null ? contentType : contentType = "application/json";
+    const response = await (0, import_cross_fetch.default)(this.baseUrl + path, {
+      method: method || "GET",
+      mode: "cors",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": contentType,
+        "Api-Key": this.apiKey
+      },
+      body: body ? contentType !== "application/json" ? body : JSON.stringify(body) : void 0
+    });
+    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
+    };
+  }
+};
+
+// src/products/endpoints.ts
+var ProductEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async query(opts) {
+    const response = await this.api.fetch(`/api/products?${objectToQuery(opts)}`);
+    return paged(productSchema).parse(response.data);
+  }
+  async get(id) {
+    const response = await this.api.fetch(`/api/products/${id}`);
+    return productSchema.parse(response.data);
+  }
+};
+
+// src/trials/endpoints.ts
+var TrialEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async request(productId, target) {
+    const response = await this.api.fetch(`/api/trials/${productId}/request`, "POST", target);
+    return trialSchema.parse(response.data);
+  }
+};
+
+// src/index.ts
+var MoonbaseClient = class {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.configuration.endpoint = this.configuration.endpoint.replace(/\/$/, "");
+    const api = new MoonbaseApi(this.configuration.endpoint, this.configuration.apiKey);
+    this.activationRequests = new ActivationRequestEndpoints(api);
+    this.customers = new CustomerEndpoints(api);
+    this.licenses = new LicenseEndpoints(api);
+    this.products = new ProductEndpoints(api);
+    this.trials = new TrialEndpoints(api);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivationMethod,
+  ActivationRequestStatus,
+  ActivationStatus,
+  LicenseStatus,
+  MoonbaseClient,
+  MoonbaseError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  ProductStatus,
+  TrialStatus
+});