@moonbase.sh/storefront-api 0.1.78

package/dist/index.js

@@ -0,0 +1,640 @@
+// src/identity/endpoints.ts
+import fetch from "cross-fetch";
+
+// src/utils/problemHandler.ts
+import { z } 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";
+  }
+};
+
+// src/utils/problemHandler.ts
+var problemDetailsSchema = z.object({
+  type: z.string(),
+  title: z.string(),
+  detail: z.string().optional(),
+  status: 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");
+  }
+  if (problemDetails.detail)
+    throw new Error(problemDetails.detail);
+  if (problemDetails.title)
+    throw new Error(problemDetails.title);
+  throw new Error("An unknown problem occurred");
+}
+
+// src/identity/schemas.ts
+import { z as z2 } from "zod";
+var addressSchema = z2.object({
+  countryCode: z2.string(),
+  streetAddress1: z2.string(),
+  streetAddress2: z2.string().nullable(),
+  locality: z2.string().nullable(),
+  region: z2.string().nullable(),
+  postCode: z2.string()
+});
+var communicationPreferencesSchema = z2.object({
+  newsletterOptIn: z2.boolean()
+  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+});
+var userSchema = z2.object({
+  id: z2.string(),
+  email: z2.string(),
+  name: z2.string(),
+  tenantId: z2.string(),
+  address: addressSchema.optional(),
+  communicationPreferences: communicationPreferencesSchema
+});
+var identityUserSchema = userSchema.and(z2.object({
+  accessToken: z2.string(),
+  refreshToken: z2.string()
+}));
+
+// src/identity/endpoints.ts
+var IdentityEndpoints = class {
+  constructor(api, tokenStore) {
+    this.api = api;
+    this.tokenStore = tokenStore;
+  }
+  async get() {
+    const response = await this.api.authenticatedFetch("/api/customer/meta/user");
+    return userSchema.parse(response);
+  }
+  async signIn(email, password) {
+    const response = await fetch(`${this.api.baseUrl}/api/customer/identity/sign-in?email=${email}&scheme=JWT`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: password
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response);
+    const data = await response.json();
+    const user = identityUserSchema.parse(data);
+    this.tokenStore.setUser(user);
+    return user;
+  }
+  async signUp(name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) {
+    const response = await this.api.fetch(`/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`, "POST", {
+      name,
+      email,
+      password,
+      address,
+      acceptedPrivacyPolicy,
+      acceptedTermsAndConditions
+    });
+    const user = identityUserSchema.parse(response);
+    this.tokenStore.setUser(user);
+    return user;
+  }
+  async update(name, email, emailConfirmationToken, communicationPreferences) {
+    const response = await this.api.authenticatedFetch("/api/customer/identity", "PATCH", {
+      name,
+      email,
+      emailConfirmationToken,
+      communicationPreferences
+    });
+    return {
+      needsEmailConfirmationToken: response.status === 201
+    };
+  }
+  async setPassword(currentPassword, newPassword) {
+    await this.api.authenticatedFetch(`/api/customer/identity/set-password`, "POST", {
+      currentPassword,
+      newPassword
+    });
+  }
+  async forgotPassword(email) {
+    await this.api.fetch(`/api/customer/identity/forgot-password?email=${encodeURIComponent(email)}`, "POST");
+  }
+  async resetPassword(email, newPassword, code) {
+    const response = await fetch(`${this.api.baseUrl}/api/customer/identity/reset-password?email=${encodeURIComponent(email)}&code=${code}`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: newPassword
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response);
+  }
+};
+
+// src/globalSchemas.ts
+import { z as z3 } from "zod";
+var priceCollectionSchema = z3.record(z3.number());
+var percentageOffDiscountSchema = z3.object({
+  type: z3.literal("PercentageOffDiscount"),
+  name: z3.string(),
+  description: z3.string().optional(),
+  percentage: z3.number(),
+  total: priceCollectionSchema
+});
+var flatAmountOffDiscountSchema = z3.object({
+  type: z3.literal("FlatAmountOffDiscount"),
+  name: z3.string(),
+  description: z3.string().optional(),
+  total: priceCollectionSchema
+});
+var discountSchema = z3.discriminatedUnion("type", [
+  percentageOffDiscountSchema,
+  flatAmountOffDiscountSchema
+]);
+var pricingVariationSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  originalPrice: priceCollectionSchema,
+  price: priceCollectionSchema,
+  hasDiscount: z3.boolean(),
+  discount: discountSchema.optional()
+});
+function paged(itemSchema) {
+  return z3.object({
+    items: z3.array(itemSchema),
+    hasMore: z3.boolean(),
+    next: z3.string().nullable()
+  });
+}
+function quantifiable(itemSchema) {
+  return z3.object({
+    value: itemSchema,
+    quantity: z3.number()
+  });
+}
+
+// src/licenses/schemas.ts
+import { z as z5 } from "zod";
+
+// src/products/schemas.ts
+import { z as z4 } from "zod";
+
+// src/products/models.ts
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["Universal"] = "Universal";
+  Platform2["Windows"] = "Windows";
+  Platform2["Linux"] = "Linux";
+  Platform2["Mac"] = "Mac";
+  return Platform2;
+})(Platform || {});
+
+// src/products/schemas.ts
+var downloadSchema = z4.object({
+  name: z4.string(),
+  key: z4.string(),
+  platform: z4.nativeEnum(Platform),
+  size: z4.number(),
+  path: z4.string().nullable()
+});
+var productSummarySchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  tagline: z4.string(),
+  website: z4.string().optional(),
+  iconUrl: z4.string().optional(),
+  numberOfLicenses: z4.number().optional(),
+  numberOfTrials: z4.number().optional(),
+  currentActivations: z4.number().optional(),
+  maxActivations: z4.number().optional(),
+  currentVersion: z4.string().nullable(),
+  downloadsNeedsUser: z4.boolean(),
+  downloadsNeedsOwnership: z4.boolean(),
+  downloads: z4.array(downloadSchema).optional()
+});
+
+// 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 = z5.object({
+  id: z5.string(),
+  status: z5.nativeEnum(LicenseStatus),
+  product: productSummarySchema.optional(),
+  activeNumberOfActivations: z5.number(),
+  maxNumberOfActivations: z5.number(),
+  createdAt: z5.coerce.date()
+});
+var activationSchema = z5.object({
+  id: z5.string(),
+  licenseId: z5.string(),
+  name: z5.string(),
+  status: z5.nativeEnum(ActivationStatus),
+  activationMethod: z5.nativeEnum(ActivationMethod),
+  lastValidatedAt: z5.coerce.date().nullable()
+});
+
+// src/licenses/endpoints.ts
+var LicenseEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/licenses");
+    return paged(licenseSchema).parse(response);
+  }
+  async getActivations(licenseId, nextUrl) {
+    const response = await this.api.authenticatedFetch(
+      nextUrl || `/api/customer/licenses/${licenseId}/activations`
+    );
+    return paged(activationSchema).parse(response);
+  }
+  async revokeActivation(licenseId, activationId) {
+    await this.api.authenticatedFetch(`/api/customer/licenses/${licenseId}/activations/${activationId}/revoke`);
+  }
+};
+
+// src/orders/schemas.ts
+import { z as z7 } from "zod";
+
+// src/storefront/schemas.ts
+import { z as z6 } from "zod";
+var storefrontProductSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  tagline: z6.string(),
+  iconUrl: z6.string().nullable(),
+  owned: z6.boolean(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  type: z6.void().transform(() => "product").pipe(z6.literal("product"))
+});
+var storefrontBundleSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  tagline: z6.string(),
+  iconUrl: z6.string().nullable(),
+  owned: z6.boolean(),
+  partial: z6.boolean(),
+  products: storefrontProductSchema.and(z6.object({
+    included: z6.boolean()
+  })).array(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  type: z6.void().transform(() => "bundle").pipe(z6.literal("bundle"))
+});
+var storefrontSchema = z6.object({
+  suggestedCurrency: z6.string(),
+  products: storefrontProductSchema.array(),
+  bundles: storefrontBundleSchema.array()
+});
+
+// src/orders/models.ts
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["Open"] = "Open";
+  OrderStatus2["PaymentRequested"] = "PaymentRequested";
+  OrderStatus2["Completed"] = "Completed";
+  OrderStatus2["Fulfilled"] = "Fulfilled";
+  OrderStatus2["Returned"] = "Returned";
+  OrderStatus2["Failed"] = "Failed";
+  return OrderStatus2;
+})(OrderStatus || {});
+
+// src/orders/schemas.ts
+var couponSchema = z7.object({
+  code: z7.string(),
+  name: z7.string(),
+  description: z7.string()
+});
+var percentageOffDiscountSchema2 = z7.object({
+  type: z7.literal("PercentageOffDiscount"),
+  name: z7.string(),
+  description: z7.string().optional(),
+  percentage: z7.number(),
+  total: priceCollectionSchema.optional(),
+  isExclusive: z7.boolean()
+});
+var flatAmountOffDiscountSchema2 = z7.object({
+  type: z7.literal("FlatAmountOffDiscount"),
+  name: z7.string(),
+  description: z7.string().optional(),
+  total: priceCollectionSchema.optional(),
+  isExclusive: z7.boolean()
+});
+var discountSchema2 = z7.discriminatedUnion("type", [
+  percentageOffDiscountSchema2,
+  flatAmountOffDiscountSchema2
+]);
+var openProductLineItem = z7.object({
+  id: z7.string(),
+  type: z7.literal("Product"),
+  productId: z7.string(),
+  quantity: z7.number(),
+  variationId: z7.string(),
+  price: priceCollectionSchema.optional(),
+  variation: pricingVariationSchema.optional(),
+  product: storefrontProductSchema.optional(),
+  appliedDiscount: discountSchema2.optional()
+});
+var openBundleLineItem = z7.object({
+  id: z7.string(),
+  type: z7.literal("Bundle"),
+  bundleId: z7.string(),
+  quantity: z7.number(),
+  variationId: z7.string(),
+  price: priceCollectionSchema.optional(),
+  variation: pricingVariationSchema.optional(),
+  bundle: storefrontBundleSchema.optional(),
+  appliedDiscount: discountSchema2.optional()
+});
+var openOrderLineItem = z7.discriminatedUnion("type", [
+  openProductLineItem,
+  openBundleLineItem
+]);
+var openOrderSchema = z7.object({
+  id: z7.string(),
+  status: z7.literal("Open" /* Open */),
+  currency: z7.string(),
+  items: openOrderLineItem.array(),
+  couponsApplied: couponSchema.array(),
+  checkoutUrl: z7.string().optional()
+});
+var orderSchema = z7.discriminatedUnion("status", [
+  openOrderSchema
+]);
+
+// src/orders/endpoints.ts
+var OrderEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(orderId) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}`);
+    return orderSchema.parse(response);
+  }
+  async pushContent(order, checkout) {
+    const response = await this.api.fetch(
+      `/api/customer/orders/${order.id}${checkout ? `?checkout=true&returnUrl=${encodeURIComponent(checkout.returnUrl)}` : ""}`,
+      "PATCH",
+      {
+        currency: order.currency,
+        items: order.items
+      }
+    );
+    return openOrderSchema.parse(response);
+  }
+};
+
+// src/products/endpoints.ts
+var ProductEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async getOwned(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/products");
+    return paged(productSummarySchema).parse(response);
+  }
+  async getLicenses(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/products/${productId}/licenses`);
+    return paged(licenseSchema).parse(response);
+  }
+  async getActivations(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/products/${productId}/licenses/activations`);
+    return paged(activationSchema).parse(response);
+  }
+};
+
+// src/storefront/endpoints.ts
+var StorefrontEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get() {
+    const response = await this.api.fetch("/api/customer/storefront");
+    return storefrontSchema.parse(response);
+  }
+};
+
+// src/utils/api.ts
+import fetch2 from "cross-fetch";
+var MoonbaseApi = class {
+  constructor(baseUrl, tokenStore) {
+    this.baseUrl = baseUrl;
+    this.tokenStore = tokenStore;
+  }
+  async authenticatedFetch(path, method, body) {
+    if (!this.tokenStore.hasAccessToken)
+      throw new NotAuthenticatedError();
+    return await this.fetch(path, method, body);
+  }
+  async fetch(path, method, body) {
+    const accessToken = await this.tokenStore.getAccessToken();
+    const response = await fetch2(this.baseUrl + path, {
+      method: method || "GET",
+      mode: "cors",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        // While this fetch can be anonymous, we add the token if we have it
+        ...accessToken ? { Authorization: `Bearer ${accessToken}` } : {},
+        // Force CORS on all calls
+        "x-mb-cors": "1"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response);
+    return await response.json();
+  }
+};
+
+// src/utils/tokenStore.ts
+import fetch3 from "cross-fetch";
+var _TokenStore = class _TokenStore {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.tokens = null;
+    this.refreshTimeoutId = null;
+    this.refreshPromise = null;
+    if (typeof window !== "undefined") {
+      window.addEventListener("storage", (event) => this.handleStorageUpdate(event));
+      const storedTokens = localStorage.getItem(_TokenStore.storageKey);
+      if (storedTokens) {
+        this.tokens = JSON.parse(storedTokens);
+        this.tokens.expiresAt = new Date(this.tokens.expiresAt);
+      }
+    }
+  }
+  get user() {
+    if (this.tokens)
+      return this.tokens;
+    return null;
+  }
+  get hasAccessToken() {
+    return !!this.tokens;
+  }
+  async getAccessToken() {
+    var _a, _b, _c;
+    if (this.isExpired) {
+      if (this.refreshPromise) {
+        const tokens2 = await this.refreshPromise;
+        return (_a = tokens2 == null ? void 0 : tokens2.accessToken) != null ? _a : null;
+      }
+      this.refreshPromise = this.refreshTokens();
+      const tokens = await this.refreshPromise;
+      return (_b = tokens == null ? void 0 : tokens.accessToken) != null ? _b : null;
+    }
+    return ((_c = this.tokens) == null ? void 0 : _c.accessToken) || null;
+  }
+  setUser(user) {
+    if (user === null) {
+      this.tokens = null;
+      if (typeof window !== "undefined" && localStorage)
+        localStorage.removeItem(_TokenStore.storageKey);
+      if (this.refreshTimeoutId != null)
+        window.clearTimeout(this.refreshTimeoutId);
+      return null;
+    }
+    this.tokens = {
+      ...user,
+      // Hardcoded 15 minutes now, might want to check the JWT tho
+      expiresAt: new Date((/* @__PURE__ */ new Date()).getTime() + 15 * 60 * 1e3)
+    };
+    if (typeof window !== "undefined" && localStorage)
+      localStorage.setItem(_TokenStore.storageKey, JSON.stringify(this.tokens));
+    if (this.refreshTimeoutId != null)
+      window.clearTimeout(this.refreshTimeoutId);
+    this.refreshTimeoutId = window.setTimeout(() => {
+      this.refreshPromise = this.refreshTokens();
+    }, 10 * 60 * 1e3);
+    return this.tokens;
+  }
+  get isExpired() {
+    return this.tokens != null && this.tokens.expiresAt < /* @__PURE__ */ new Date();
+  }
+  async refreshTokens() {
+    if (!this.tokens)
+      throw new Error("No tokens found to refresh");
+    const response = await fetch3(`${this.configuration.endpoint}/api/customer/identity/refresh?token=${this.tokens.refreshToken}`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: this.tokens.accessToken
+    });
+    if (response.status !== 200) {
+      if (response.status === 403) {
+        this.setUser(null);
+        return null;
+      }
+      throw new Error(`Could not refresh access token, status code ${response.status}`);
+    }
+    const result = identityUserSchema.parse(await response.json());
+    return this.setUser(result);
+  }
+  handleStorageUpdate(event) {
+    switch (event.key) {
+      case _TokenStore.storageKey:
+        this.tokens = JSON.parse(event.newValue);
+        this.tokens.expiresAt = new Date(this.tokens.expiresAt);
+        break;
+    }
+  }
+};
+_TokenStore.storageKey = "moonbase_auth";
+var TokenStore = _TokenStore;
+
+// src/vouchers/schemas.ts
+import { z as z8 } from "zod";
+var voucherSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  description: z8.string(),
+  code: z8.string(),
+  redeemed: z8.boolean(),
+  redeemsProducts: quantifiable(storefrontProductSchema).array(),
+  redeemsBundles: quantifiable(storefrontBundleSchema).array()
+});
+
+// src/vouchers/endpoints.ts
+var VoucherEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async peek(code) {
+    const response = await this.api.fetch(`/api/customer/vouchers?code=${encodeURIComponent(code)}`);
+    return voucherSchema.parse(response);
+  }
+  async redeem(code) {
+    const response = await this.api.authenticatedFetch(
+      `/api/customer/vouchers/redeem?code=${encodeURIComponent(code)}`,
+      "POST"
+    );
+    return voucherSchema.parse(response);
+  }
+};
+
+// src/index.ts
+var MoonbaseClient = class {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.configuration.endpoint = this.configuration.endpoint.replace(/\/$/, "");
+    this.tokenStore = new TokenStore(configuration);
+    const api = new MoonbaseApi(this.configuration.endpoint, this.tokenStore);
+    this.storefront = new StorefrontEndpoints(api);
+    this.identity = new IdentityEndpoints(api, this.tokenStore);
+    this.vouchers = new VoucherEndpoints(api);
+    this.orders = new OrderEndpoints(api);
+    this.licenses = new LicenseEndpoints(api);
+    this.products = new ProductEndpoints(api);
+  }
+};
+export {
+  ActivationMethod,
+  ActivationStatus,
+  LicenseStatus,
+  MoonbaseClient,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  OrderStatus,
+  Platform
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@moonbase.sh/storefront-api",
+  "type": "module",
+  "version": "0.1.78",
+  "description": "Package to let you build storefronts 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"
+  }
+}