@vibedout/commerce 0.0.0-stage → 0.2.4

package/dist/totals.d.mts

@@ -0,0 +1,82 @@
+import { n as CommerceProblem } from "./errors-DGzIIflf.mjs";
+import { N as LineSnapshot, W as ResolvedLine, _ as Fulfilment, at as TaxBreakdown, ct as TaxResult, r as AppliedDiscount, rt as StockSubject } from "./types-BUyLunnB.mjs";
+//#region src/totals.d.ts
+interface PricedLine {
+  ref: string;
+  title: string;
+  quantity: number;
+  unitAmountMinor: number;
+  /** `unitAmountMinor * quantity`. */
+  lineTotalMinor: number;
+  /**
+   * What the discounts took off this line (0.2.4), never more than `lineTotalMinor`; the lines' add up to `Totals.discountMinor`. The line's
+   * share is what the discount said (`AppliedDiscount.lines`) or its part of the rest, worked once here (`attributeDiscounts`), so the tax, the
+   * payment request and the invoice state the same discount on the same line.
+   */
+  discountMinor: number;
+  currency: string;
+  taxCode?: string;
+  taxIncluded: boolean;
+  fulfilment: Fulfilment;
+  /** What inventory holds this line under: hold with `holdLinesFrom`, not with the `ref`. */
+  stock?: StockSubject;
+  /** What the order keeps of the line. */
+  snapshot: LineSnapshot;
+}
+/**
+ * The shipping rate the buyer chose, as the shipping port quoted it just now (never an amount from the browser). A `ShippingRate` is one, and
+ * its `currency` must be the order's.
+ */
+interface ChosenShipping {
+  id?: string;
+  title: string;
+  amountMinor: number;
+  currency: string;
+}
+interface TotalsInput {
+  /** Every line must be `available` and within its `maxQuantity`: use `partitionLines` first to show the others. */
+  lines: readonly ResolvedLine[];
+  /** From the discount port's `applied`, each in the order's currency. Their sum may not exceed the subtotal. */
+  discounts?: readonly AppliedDiscount[];
+  shipping?: ChosenShipping;
+  /** The tax port's answer, in the order's currency. */
+  tax?: TaxResult;
+}
+interface Totals {
+  currency: string;
+  lines: readonly PricedLine[];
+  subtotalMinor: number;
+  /** The discounts as given, each with the lines it came off (0.2.4: `attributeDiscounts`; a discount of 0 has none). */
+  discounts: readonly AppliedDiscount[];
+  discountMinor: number;
+  shipping: ChosenShipping | null;
+  shippingMinor: number;
+  /** What tax adds on top. */
+  taxMinor: number;
+  /** The tax already inside the prices, for the invoice. It is not in `totalMinor` a second time. */
+  taxIncludedMinor: number;
+  taxBreakdown: readonly TaxBreakdown[];
+  /** `subtotalMinor - discountMinor + shippingMinor + taxMinor`. */
+  totalMinor: number;
+}
+type TotalsResult = {
+  ok: true;
+  totals: Totals;
+} | {
+  ok: false;
+  problems: readonly CommerceProblem[];
+};
+/**
+ * ```ts
+ * const result = computeTotals({ lines, discounts: discount.applied, shipping: rate, tax });
+ * if (!result.ok) return c.json({ problems: result.problems }, 422);
+ * result.totals.totalMinor; // 169900
+ * ```
+ *
+ * Every amount is in the currency of the lines: a shipping rate, a tax or a discount in another one is a `currency_mismatch`, never added.
+ */
+declare function computeTotals(input: TotalsInput): TotalsResult;
+/** The totals, or a {@link CommerceError} with the problems, for a caller that treats a refusal as a bug. */
+declare function assertTotals(result: TotalsResult): Totals;
+//#endregion
+export { ChosenShipping, PricedLine, Totals, TotalsInput, TotalsResult, assertTotals, computeTotals };

package/dist/totals.mjs

@@ -0,0 +1,130 @@
+import { CommerceError, problem } from "./errors.mjs";
+import { i as isRecord, r as isDisplayText } from "./internal-p2FS_A4L.mjs";
+import { a as isCurrencyCode, l as sumMinor, o as isMinorUnits, s as lineTotalMinor } from "./money-aFFtGd0E.mjs";
+import { attributeDiscounts } from "./discounts.mjs";
+import { blockedProblem, checkResolvedLine } from "./lines.mjs";
+//#region src/totals.ts
+/**
+* The total of an order, in minor units, from lines a source priced and the answers of the optional ports (discount, shipping, tax). It
+* refuses instead of guessing: a line that cannot be bought, two currencies, an amount that is not a whole number, a discount larger than
+* what it discounts, a tax breakdown that does not add up. It returns the problems and does not throw, so a route answers with them.
+*/
+const refuse = (...problems) => ({
+	ok: false,
+	problems
+});
+/**
+* ```ts
+* const result = computeTotals({ lines, discounts: discount.applied, shipping: rate, tax });
+* if (!result.ok) return c.json({ problems: result.problems }, 422);
+* result.totals.totalMinor; // 169900
+* ```
+*
+* Every amount is in the currency of the lines: a shipping rate, a tax or a discount in another one is a `currency_mismatch`, never added.
+*/
+function computeTotals(input) {
+	const lines = input.lines;
+	if (!Array.isArray(lines) || lines.length === 0) return refuse(problem("empty_order", "lines", "an order needs at least one line"));
+	const problems = [];
+	for (const [index, line] of lines.entries()) {
+		const path = `lines[${index}]`;
+		const shape = checkResolvedLine(line, path);
+		if (shape.length > 0) problems.push(...shape);
+		else {
+			const blocked = blockedProblem(line, path);
+			if (blocked) problems.push(blocked);
+		}
+	}
+	if (problems.length > 0) return refuse(...problems);
+	const currency = lines[0].currency;
+	for (const [index, line] of lines.entries()) if (line.currency !== currency) problems.push(problem("currency_mismatch", `lines[${index}].currency`, `${line.currency} cannot be added to ${currency}`));
+	if (problems.length > 0) return refuse(...problems);
+	const discounts = input.discounts ?? [];
+	const sameCurrency = (value, path) => {
+		if (!isCurrencyCode(value)) problems.push(problem("invalid_adjustment", path, "an adjustment states its currency, an uppercase ISO 4217 code"));
+		else if (value !== currency) problems.push(problem("currency_mismatch", path, `${value} cannot be added to ${currency}`));
+	};
+	discounts.forEach((discount, index) => {
+		if (!isRecord(discount) || !isMinorUnits(discount.amountMinor) || !isDisplayText(discount.title, 200)) problems.push(problem("invalid_adjustment", `discounts[${index}]`, "a discount has a title and a whole amount of minor units, zero or more"));
+		else sameCurrency(discount.currency, `discounts[${index}].currency`);
+	});
+	const given = input.shipping ?? null;
+	if (given && (!isRecord(given) || !isMinorUnits(given.amountMinor) || !isDisplayText(given.title, 200))) problems.push(problem("invalid_adjustment", "shipping", "a shipping rate has a title and a whole amount of minor units, zero or more"));
+	else if (given) sameCurrency(given.currency, "shipping.currency");
+	const tax = input.tax;
+	if (tax && (!isRecord(tax) || !isMinorUnits(tax.addedMinor) || !isMinorUnits(tax.includedMinor))) problems.push(problem("invalid_adjustment", "tax", "tax is whole amounts of minor units, zero or more"));
+	else if (tax) sameCurrency(tax.currency, "tax.currency");
+	tax?.breakdown?.forEach((part, index) => {
+		if (!isRecord(part) || !isMinorUnits(part.amountMinor) || typeof part.included !== "boolean") problems.push(problem("invalid_adjustment", `tax.breakdown[${index}]`, "a tax part is a whole amount of minor units, zero or more"));
+	});
+	if (problems.length > 0) return refuse(...problems);
+	const shipping = given ? {
+		...given.id === void 0 ? {} : { id: given.id },
+		title: given.title,
+		amountMinor: given.amountMinor,
+		currency
+	} : null;
+	try {
+		const priced = lines.map((line) => ({
+			ref: line.ref,
+			title: line.title,
+			quantity: line.quantity,
+			unitAmountMinor: line.unitAmountMinor,
+			lineTotalMinor: lineTotalMinor(line.unitAmountMinor, line.quantity),
+			discountMinor: 0,
+			currency,
+			...line.taxCode === void 0 ? {} : { taxCode: line.taxCode },
+			taxIncluded: line.taxIncluded,
+			fulfilment: line.fulfilment,
+			...line.stock === void 0 ? {} : { stock: line.stock },
+			snapshot: line.snapshot
+		}));
+		const subtotalMinor = sumMinor(currency, priced.map((line) => line.lineTotalMinor));
+		const discountMinor = sumMinor(currency, discounts.map((discount) => discount.amountMinor));
+		if (discountMinor > subtotalMinor) return refuse(problem("discount_exceeds_subtotal", "discounts", `discounts of ${discountMinor} exceed the subtotal of ${subtotalMinor}`));
+		const attributed = attributeDiscounts(lines, discounts);
+		for (const discount of attributed) for (const part of discount.lines ?? []) {
+			const line = priced[part.index];
+			line.discountMinor += part.amountMinor;
+		}
+		const shippingMinor = shipping?.amountMinor ?? 0;
+		const taxMinor = tax?.addedMinor ?? 0;
+		const taxIncludedMinor = tax?.includedMinor ?? 0;
+		const taxBreakdown = tax?.breakdown ?? [];
+		if (tax?.breakdown) {
+			const part = (included) => sumMinor(currency, tax.breakdown?.filter((item) => item.included === included).map((item) => item.amountMinor) ?? []);
+			if (part(false) !== taxMinor || part(true) !== taxIncludedMinor) return refuse(problem("tax_breakdown_mismatch", "tax.breakdown", "the breakdown does not add up to addedMinor and includedMinor"));
+		}
+		return {
+			ok: true,
+			totals: {
+				currency,
+				lines: priced,
+				subtotalMinor,
+				discounts: attributed,
+				discountMinor,
+				shipping,
+				shippingMinor,
+				taxMinor,
+				taxIncludedMinor,
+				taxBreakdown,
+				totalMinor: sumMinor(currency, [
+					subtotalMinor - discountMinor,
+					shippingMinor,
+					taxMinor
+				])
+			}
+		};
+	} catch (error) {
+		if (error instanceof CommerceError) return refuse(...error.problems);
+		throw error;
+	}
+}
+/** The totals, or a {@link CommerceError} with the problems, for a caller that treats a refusal as a bug. */
+function assertTotals(result) {
+	if (result.ok) return result.totals;
+	const first = result.problems[0];
+	throw new CommerceError(first.code, first.message, first.path, result.problems);
+}
+//#endregion
+export { assertTotals, computeTotals };