@moonbase.sh/api 0.1.109

package/dist/index.js

@@ -0,0 +1,346 @@
+// src/activationRequests/schemas.ts
+import { z as z5 } from "zod";
+
+// src/customers/schemas.ts
+import { z } from "zod";
+var addressSchema = z.object({
+  countryCode: z.string(),
+  streetAddress1: z.string(),
+  streetAddress2: z.string().nullable(),
+  locality: z.string().nullable(),
+  region: z.string().nullable(),
+  postCode: z.string()
+});
+var communicationPreferencesSchema = z.object({
+  newsletterOptIn: z.boolean()
+  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+});
+var customerSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  businessName: z.string().nullable(),
+  taxId: z.string().nullable(),
+  email: z.string(),
+  numberOfLicenses: z.number(),
+  numberOfTrials: z.number(),
+  emailConfirmed: z.boolean(),
+  hasPassword: z.boolean(),
+  isDeleted: z.boolean(),
+  ownedProducts: z.string().array(),
+  address: addressSchema.nullable(),
+  communicationPreferences: communicationPreferencesSchema
+});
+
+// src/licenses/schemas.ts
+import { z as z2 } from "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 = z2.object({
+  id: z2.string(),
+  status: z2.nativeEnum(LicenseStatus),
+  activeNumberOfActivations: z2.number(),
+  maxNumberOfActivations: z2.number()
+});
+var licenseActivationSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.nativeEnum(ActivationStatus),
+  activationMethod: z2.nativeEnum(ActivationMethod),
+  lastValidatedAt: z2.coerce.date(),
+  license: licenseSchema
+});
+
+// src/products/schemas.ts
+import { z as z3 } from "zod";
+
+// src/products/models.ts
+var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
+  ProductStatus2["Active"] = "Active";
+  ProductStatus2["Inactive"] = "Inactive";
+  return ProductStatus2;
+})(ProductStatus || {});
+
+// src/products/schemas.ts
+var productSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  tagline: z3.string(),
+  description: z3.string(),
+  website: z3.string().nullable(),
+  iconUrl: z3.string().nullable(),
+  status: z3.nativeEnum(ProductStatus),
+  purchasable: z3.boolean(),
+  currentReleaseVersion: z3.string().nullable()
+});
+
+// src/trials/schemas.ts
+import { z as z4 } from "zod";
+
+// src/trials/models.ts
+var TrialStatus = /* @__PURE__ */ ((TrialStatus2) => {
+  TrialStatus2["Active"] = "Active";
+  TrialStatus2["Expired"] = "Expired";
+  return TrialStatus2;
+})(TrialStatus || {});
+
+// src/trials/schemas.ts
+var trialSchema = z4.object({
+  id: z4.string(),
+  status: z4.nativeEnum(TrialStatus),
+  expiresAt: z4.coerce.date(),
+  lastValidatedAt: z4.coerce.date(),
+  ownerId: z4.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 = z5.object({
+  id: z5.string(),
+  status: z5.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
+import { z as z6 } from "zod";
+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
+});
+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 pricingVariationSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  originalPrice: priceCollectionSchema,
+  price: priceCollectionSchema,
+  hasDiscount: z6.boolean(),
+  discount: discountSchema.optional()
+});
+function paged(itemSchema) {
+  return z6.object({
+    items: z6.array(itemSchema),
+    hasMore: z6.boolean(),
+    next: z6.string().nullable()
+  });
+}
+
+// src/utils/api.ts
+import fetch from "cross-fetch";
+
+// src/utils/problemHandler.ts
+import { z as z7 } from "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 = z7.object({
+  type: z7.string(),
+  title: z7.string(),
+  detail: z7.string().optional(),
+  status: z7.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 fetch(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);
+  }
+};
+export {
+  ActivationMethod,
+  ActivationRequestStatus,
+  ActivationStatus,
+  LicenseStatus,
+  MoonbaseClient,
+  MoonbaseError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  ProductStatus,
+  TrialStatus
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@moonbase.sh/api",
+  "type": "module",
+  "version": "0.1.109",
+  "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",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "dependencies": {
+    "cross-fetch": "^3.1.5",
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "@types/node": "^18.14.2",
+    "rimraf": "^5.0.0",
+    "tsup": "^7.1.0",
+    "typescript": "~5.1.6"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "version": "npm version"
+  }
+}