@coursebuilder/core/dist/chunk-NTGLTY3X.js

Core package for Course Builder

import {
  determineCouponToApply
} from "./chunk-QDGLZ5WB.js";
import {
  getCalculatedPrice
} from "./chunk-PQKCCDCP.js";
import {
  __name,
  __publicField
} from "./chunk-VLQXSCFN.js";

// src/lib/pricing/format-prices-for-product.ts
import { sum } from "@coursebuilder/nodash";
var _PriceFormattingError = class _PriceFormattingError extends Error {
  constructor(message, options) {
    super(message);
    __publicField(this, "options");
    this.name = "PriceFormattingError";
    this.options = options;
  }
};
__name(_PriceFormattingError, "PriceFormattingError");
var PriceFormattingError = _PriceFormattingError;
async function getChainOfPurchases({ purchase, ctx }) {
  if (purchase === null) {
    return [];
  } else {
    const { getPurchase } = ctx;
    const { upgradedFromId } = purchase;
    const purchaseThisWasUpgradedFrom = upgradedFromId ? await getPurchase(upgradedFromId) : null;
    return [
      purchase,
      ...await getChainOfPurchases({
        purchase: purchaseThisWasUpgradedFrom,
        ctx
      })
    ];
  }
}
__name(getChainOfPurchases, "getChainOfPurchases");
async function getFixedDiscountForIndividualUpgrade({ purchaseToBeUpgraded, productToBePurchased, purchaseWillBeRestricted, userId, ctx }) {
  if (purchaseToBeUpgraded === null || purchaseToBeUpgraded?.productId === void 0) {
    return 0;
  }
  const transitioningToUnrestrictedAccess = purchaseToBeUpgraded.status === "Restricted" && !purchaseWillBeRestricted;
  if (transitioningToUnrestrictedAccess) {
    const purchaseChain = await getChainOfPurchases({
      purchase: purchaseToBeUpgraded,
      ctx
    });
    return sum(purchaseChain.map((purchase) => purchase.totalAmount));
  }
  const { availableUpgradesForProduct, pricesOfPurchasesTowardOneBundle } = ctx;
  const availableUpgrades = await availableUpgradesForProduct([
    purchaseToBeUpgraded
  ], productToBePurchased.id);
  const upgradeIsAvailable = availableUpgrades.length > 0;
  if (upgradeIsAvailable) {
    const pricesToBeDiscounted = await pricesOfPurchasesTowardOneBundle({
      userId,
      bundleId: productToBePurchased.id
    });
    const pricesArray = pricesToBeDiscounted.map((price) => {
      return price.unitAmount;
    });
    return sum(pricesArray);
  }
  return 0;
}
__name(getFixedDiscountForIndividualUpgrade, "getFixedDiscountForIndividualUpgrade");
async function formatPricesForProduct(options) {
  const { ctx, ...noContextOptions } = options;
  const { productId, country = "US", quantity = 1, merchantCouponId, upgradeFromPurchaseId, userId, autoApplyPPP = true, usedCouponId } = noContextOptions;
  if (!productId)
    throw new Error("productId is required");
  const { getProduct, getPriceForProduct, getPurchase, getCoupon } = ctx;
  const usedCoupon = usedCouponId ? await getCoupon(usedCouponId) : null;
  const upgradeFromPurchase = upgradeFromPurchaseId ? await getPurchase(upgradeFromPurchaseId) : null;
  const upgradedProduct = upgradeFromPurchase ? await getProduct(upgradeFromPurchase.productId) : null;
  const product = await getProduct(productId);
  if (!product) {
    throw new PriceFormattingError(`no-product-found`, noContextOptions);
  }
  const price = await getPriceForProduct(productId);
  if (!price)
    throw new PriceFormattingError(`no-price-found`, noContextOptions);
  const { appliedMerchantCoupon, appliedCouponType, ...result } = await determineCouponToApply({
    prismaCtx: ctx,
    merchantCouponId,
    country,
    quantity,
    userId,
    productId: product.id,
    purchaseToBeUpgraded: upgradeFromPurchase,
    autoApplyPPP,
    usedCoupon
  });
  const fireFixedDiscountForIndividualUpgrade = /* @__PURE__ */ __name(async () => {
    return await getFixedDiscountForIndividualUpgrade({
      purchaseToBeUpgraded: upgradeFromPurchase,
      productToBePurchased: product,
      purchaseWillBeRestricted: appliedCouponType === "ppp",
      userId,
      ctx
    });
  }, "fireFixedDiscountForIndividualUpgrade");
  const fixedDiscountForUpgrade = result.bulk ? 0 : await fireFixedDiscountForIndividualUpgrade();
  const unitPrice = price.unitAmount;
  const fullPrice = unitPrice * quantity - fixedDiscountForUpgrade;
  const percentOfDiscount = appliedMerchantCoupon?.percentageDiscount;
  const upgradeDetails = upgradeFromPurchase !== null && appliedCouponType !== "bulk" ? {
    upgradeFromPurchaseId,
    upgradeFromPurchase,
    upgradedProduct
  } : {};
  return {
    ...product,
    quantity,
    unitPrice,
    fullPrice,
    fixedDiscountForUpgrade,
    calculatedPrice: getCalculatedPrice({
      unitPrice,
      percentOfDiscount,
      fixedDiscount: fixedDiscountForUpgrade,
      quantity
    }),
    availableCoupons: result.availableCoupons,
    appliedMerchantCoupon,
    ...usedCoupon?.merchantCouponId === appliedMerchantCoupon?.id && {
      usedCouponId
    },
    bulk: result.bulk,
    ...upgradeDetails
  };
}
__name(formatPricesForProduct, "formatPricesForProduct");

export {
  PriceFormattingError,
  getFixedDiscountForIndividualUpgrade,
  formatPricesForProduct
};
//# sourceMappingURL=chunk-NTGLTY3X.js.map