@mercurjs/core 2.3.6-canary.0 → 2.3.6-canary.10

package/.medusa/server/src/workflows/payment/utils/split-order-payment-group.d.ts

@@ -0,0 +1,141 @@
+import { BigNumberInput, LinkDefinition, MedusaContainer } from "@medusajs/framework/types";
+/** Set on a cart's payment collection once it is split into its orders'. */
+export declare const SPLIT_ORDER_COLLECTIONS_FLAG = "split_order_collections";
+/** Set on an order's payment collection, pointing at the cart's. */
+export declare const CART_PAYMENT_COLLECTION_KEY = "cart_payment_collection_id";
+type PaymentMovement = {
+    id: string;
+    amount: BigNumberInput;
+    raw_amount?: BigNumberInput | null;
+};
+export type SplitOrderGroupPayment = {
+    id: string;
+    provider_id: string;
+    currency_code: string;
+    amount: BigNumberInput;
+    raw_amount?: BigNumberInput | null;
+    data?: Record<string, unknown> | null;
+    captured_at?: Date | string | null;
+    canceled_at?: Date | string | null;
+    captures?: PaymentMovement[] | null;
+    refunds?: PaymentMovement[] | null;
+};
+export type SplitOrderGroupCollection = {
+    id: string;
+    currency_code: string;
+    metadata?: Record<string, unknown> | null;
+    payments?: SplitOrderGroupPayment[] | null;
+};
+export type SplitOrderGroupOrder = {
+    id: string;
+    status: string;
+    canceled_at?: Date | string | null;
+    total: BigNumberInput;
+    payment_collections?: SplitOrderGroupCollection[] | null;
+};
+/** Fields to query on `cart_payment_collection` to plan a split or a void. */
+export declare const cartPaymentCollectionFields: string[];
+/** Fields to query on `order_cart` to plan a split or a void. */
+export declare const cartOrderFields: string[];
+export declare const isPaymentCaptured: (payment: SplitOrderGroupPayment) => boolean;
+export declare const isOrderCanceled: (order: {
+    status: string;
+    canceled_at?: Date | string | null;
+}) => boolean;
+export declare const hasSplitOrderCollections: (paymentCollection?: {
+    metadata?: Record<string, unknown> | null;
+} | null) => boolean;
+/**
+ * The payment collections that pay for an order. Until the cart payment is
+ * captured that is the cart's shared collection; afterwards the order has its
+ * own. An order canceled before the capture never gets one and keeps showing
+ * the cart's.
+ */
+export declare const resolveOrderPaymentCollections: (order: {
+    cart?: {
+        payment_collection?: {
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    } | null;
+    payment_collections?: unknown[];
+}) => unknown[];
+/**
+ * Resolves the cart a payment or an order belongs to. A payment can be the
+ * cart's own or one created for an order when the cart payment was split.
+ */
+export declare const resolveSplitOrderCartId: (container: MedusaContainer, input: {
+    order_id: string;
+} | {
+    payment_id: string;
+}) => Promise<string | undefined>;
+export type CartPaymentSplitPlan = {
+    /** Payment collections to create, one per order that has none yet. */
+    collections: {
+        order_id: string;
+        currency_code: string;
+        amount: BigNumberInput;
+        metadata: Record<string, unknown>;
+    }[];
+    /**
+     * Payments to create. `payment_collection_id` is unset for an order whose
+     * collection is created in the same run.
+     */
+    payments: {
+        order_id: string;
+        payment_collection_id?: string;
+        provider_id: string;
+        currency_code: string;
+        amount: BigNumberInput;
+        data: Record<string, unknown>;
+    }[];
+    /**
+     * Captures to record. `payment_id` is unset for an order whose payment is
+     * created in the same run.
+     */
+    captures: {
+        order_id: string;
+        payment_id?: string;
+        amount: BigNumberInput;
+    }[];
+    /**
+     * Captures the orders' payments already hold. Their order transactions are
+     * written again on every run, which is a no-op unless an earlier run stopped
+     * between recording a capture and writing its transaction.
+     */
+    recorded: {
+        order_id: string;
+        currency_code: string;
+        capture_id: string;
+        amount: BigNumberInput;
+    }[];
+    /** What was charged for orders canceled before the capture. */
+    refunds: {
+        payment_id: string;
+        amount: BigNumberInput;
+        note: string;
+    }[];
+    /** Set when the cart collection still has to be flagged as split. */
+    cart_payment_collection?: {
+        id: string;
+        metadata: Record<string, unknown>;
+    };
+};
+/**
+ * Works out what is missing for every order of a cart to hold its share of
+ * what the cart payment has captured. Only ever plans the difference, so a
+ * cart that is already split yields an empty plan.
+ */
+export declare const planCartPaymentSplit: (cartCollection: SplitOrderGroupCollection | null | undefined, orders: SplitOrderGroupOrder[]) => CartPaymentSplitPlan;
+/** The links between the orders and the payment collections created for them. */
+export declare const buildOrderPaymentCollectionLinks: (plan: CartPaymentSplitPlan, createdCollections: {
+    id: string;
+}[]) => LinkDefinition[];
+/**
+ * The cart payment to void: set once every order of the cart is canceled and
+ * nothing of the payment was captured.
+ */
+export declare const planCartPaymentVoid: (cartCollection: SplitOrderGroupCollection | null | undefined, orders: SplitOrderGroupOrder[]) => {
+    payment_ids: string[];
+    payment_collection_ids: string[];
+};
+export {};

package/.medusa/server/src/workflows/payment/utils/split-order-payment-group.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCartPaymentVoid = exports.buildOrderPaymentCollectionLinks = exports.planCartPaymentSplit = exports.resolveSplitOrderCartId = exports.resolveOrderPaymentCollections = exports.hasSplitOrderCollections = exports.isOrderCanceled = exports.isPaymentCaptured = exports.cartOrderFields = exports.cartPaymentCollectionFields = exports.CART_PAYMENT_COLLECTION_KEY = exports.SPLIT_ORDER_COLLECTIONS_FLAG = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const split_order_payment_1 = require("./split-order-payment");
+/** Set on a cart's payment collection once it is split into its orders'. */
+exports.SPLIT_ORDER_COLLECTIONS_FLAG = "split_order_collections";
+/** Set on an order's payment collection, pointing at the cart's. */
+exports.CART_PAYMENT_COLLECTION_KEY = "cart_payment_collection_id";
+const PAYMENT_FIELDS = [
+    "id",
+    "provider_id",
+    "currency_code",
+    "amount",
+    "raw_amount",
+    "data",
+    "captured_at",
+    "canceled_at",
+    "captures.id",
+    "captures.amount",
+    "captures.raw_amount",
+    "refunds.id",
+    "refunds.amount",
+    "refunds.raw_amount",
+];
+const COLLECTION_FIELDS = [
+    "id",
+    "currency_code",
+    "metadata",
+    ...PAYMENT_FIELDS.map((field) => `payments.${field}`),
+];
+/** Fields to query on `cart_payment_collection` to plan a split or a void. */
+exports.cartPaymentCollectionFields = COLLECTION_FIELDS.map((field) => `payment_collection.${field}`);
+/** Fields to query on `order_cart` to plan a split or a void. */
+exports.cartOrderFields = [
+    "order.id",
+    "order.status",
+    "order.canceled_at",
+    "order.total",
+    ...COLLECTION_FIELDS.map((field) => `order.payment_collections.${field}`),
+];
+const amountOf = (movement) => movement.raw_amount ?? movement.amount;
+const sum = (movements) => (movements ?? []).reduce((acc, movement) => utils_1.MathBN.add(acc, amountOf(movement)), utils_1.MathBN.convert(0));
+const isPaymentCaptured = (payment) => !!payment.captured_at || (payment.captures ?? []).length > 0;
+exports.isPaymentCaptured = isPaymentCaptured;
+const isOrderCanceled = (order) => order.status === utils_1.OrderStatus.CANCELED || !!order.canceled_at;
+exports.isOrderCanceled = isOrderCanceled;
+const hasSplitOrderCollections = (paymentCollection) => paymentCollection?.metadata?.[exports.SPLIT_ORDER_COLLECTIONS_FLAG] === true;
+exports.hasSplitOrderCollections = hasSplitOrderCollections;
+/**
+ * The payment collections that pay for an order. Until the cart payment is
+ * captured that is the cart's shared collection; afterwards the order has its
+ * own. An order canceled before the capture never gets one and keeps showing
+ * the cart's.
+ */
+const resolveOrderPaymentCollections = (order) => {
+    const own = order.payment_collections ?? [];
+    const cartPaymentCollection = order.cart?.payment_collection;
+    if (!cartPaymentCollection) {
+        return own;
+    }
+    return (0, exports.hasSplitOrderCollections)(cartPaymentCollection) && own.length
+        ? own
+        : [cartPaymentCollection];
+};
+exports.resolveOrderPaymentCollections = resolveOrderPaymentCollections;
+/**
+ * Resolves the cart a payment or an order belongs to. A payment can be the
+ * cart's own or one created for an order when the cart payment was split.
+ */
+const resolveSplitOrderCartId = async (container, input) => {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    if ("order_id" in input) {
+        const { data: [orderCart], } = await query.graph({
+            entity: "order_cart",
+            fields: ["cart_id"],
+            filters: { order_id: input.order_id },
+        });
+        return orderCart?.cart_id;
+    }
+    const { data: [payment], } = await query.graph({
+        entity: "payment",
+        fields: ["id", "payment_collection.id", "payment_collection.metadata"],
+        filters: { id: input.payment_id },
+    });
+    const collection = payment?.payment_collection;
+    if (!collection) {
+        return undefined;
+    }
+    const { data: [cartLink], } = await query.graph({
+        entity: "cart_payment_collection",
+        fields: ["cart_id"],
+        filters: {
+            payment_collection_id: collection.metadata?.[exports.CART_PAYMENT_COLLECTION_KEY] ?? collection.id,
+        },
+    });
+    return cartLink?.cart_id;
+};
+exports.resolveSplitOrderCartId = resolveSplitOrderCartId;
+const getCartPayment = (collection) => (collection?.payments ?? []).find((payment) => !payment.canceled_at);
+const getOrderCollection = (order, cartCollectionId) => (order.payment_collections ?? []).find((collection) => collection.metadata?.[exports.CART_PAYMENT_COLLECTION_KEY] === cartCollectionId);
+const EMPTY_PLAN = {
+    collections: [],
+    payments: [],
+    captures: [],
+    recorded: [],
+    refunds: [],
+};
+/**
+ * Works out what is missing for every order of a cart to hold its share of
+ * what the cart payment has captured. Only ever plans the difference, so a
+ * cart that is already split yields an empty plan.
+ */
+const planCartPaymentSplit = (cartCollection, orders) => {
+    const cartPayment = getCartPayment(cartCollection);
+    if (!cartCollection || !cartPayment || !orders.length) {
+        return EMPTY_PLAN;
+    }
+    const captured = sum(cartPayment.captures);
+    if (!utils_1.MathBN.gt(captured, 0)) {
+        return EMPTY_PLAN;
+    }
+    const decimalDigits = (0, split_order_payment_1.getCurrencyDecimalDigits)(cartPayment.currency_code);
+    const weights = orders.map((order) => order.total);
+    // What each order is entitled to of the authorization, and of the part of
+    // it captured so far.
+    const shares = (0, split_order_payment_1.allocateProportionally)({
+        amount: amountOf(cartPayment),
+        weights,
+        decimalDigits,
+    });
+    const targets = (0, split_order_payment_1.allocateProportionally)({
+        amount: captured,
+        weights,
+        decimalDigits,
+    });
+    const plan = {
+        collections: [],
+        payments: [],
+        captures: [],
+        recorded: [],
+        refunds: [],
+    };
+    let attributed = utils_1.MathBN.convert(0);
+    orders.forEach((order, index) => {
+        const collection = getOrderCollection(order, cartCollection.id);
+        const payment = collection?.payments?.[0];
+        const recorded = sum(payment?.captures);
+        const missing = utils_1.MathBN.sub(targets[index], recorded);
+        attributed = utils_1.MathBN.add(attributed, recorded);
+        for (const capture of payment?.captures ?? []) {
+            plan.recorded.push({
+                order_id: order.id,
+                currency_code: cartPayment.currency_code,
+                capture_id: capture.id,
+                amount: amountOf(capture),
+            });
+        }
+        // An order canceled before the capture is not paid: its part of the
+        // charge stays unattributed and is refunded.
+        if ((0, exports.isOrderCanceled)(order) || !utils_1.MathBN.gt(missing, 0)) {
+            return;
+        }
+        if (!collection) {
+            plan.collections.push({
+                order_id: order.id,
+                currency_code: cartPayment.currency_code,
+                amount: shares[index],
+                metadata: { [exports.CART_PAYMENT_COLLECTION_KEY]: cartCollection.id },
+            });
+        }
+        if (!payment) {
+            plan.payments.push({
+                order_id: order.id,
+                payment_collection_id: collection?.id,
+                provider_id: cartPayment.provider_id,
+                currency_code: cartPayment.currency_code,
+                amount: shares[index],
+                data: cartPayment.data ?? {},
+            });
+        }
+        plan.captures.push({
+            order_id: order.id,
+            payment_id: payment?.id,
+            amount: missing,
+        });
+        attributed = utils_1.MathBN.add(attributed, missing);
+    });
+    const unattributed = utils_1.MathBN.sub(captured, attributed, sum(cartPayment.refunds));
+    if (utils_1.MathBN.gt(unattributed, 0)) {
+        plan.refunds.push({
+            payment_id: cartPayment.id,
+            amount: unattributed,
+            note: "Share of orders canceled before the payment was captured",
+        });
+    }
+    if (!(0, exports.hasSplitOrderCollections)(cartCollection)) {
+        plan.cart_payment_collection = {
+            id: cartCollection.id,
+            metadata: {
+                ...cartCollection.metadata,
+                [exports.SPLIT_ORDER_COLLECTIONS_FLAG]: true,
+            },
+        };
+    }
+    return plan;
+};
+exports.planCartPaymentSplit = planCartPaymentSplit;
+/** The links between the orders and the payment collections created for them. */
+const buildOrderPaymentCollectionLinks = (plan, createdCollections) => plan.collections.map((collection, index) => ({
+    [utils_1.Modules.ORDER]: { order_id: collection.order_id },
+    [utils_1.Modules.PAYMENT]: { payment_collection_id: createdCollections[index].id },
+}));
+exports.buildOrderPaymentCollectionLinks = buildOrderPaymentCollectionLinks;
+/**
+ * The cart payment to void: set once every order of the cart is canceled and
+ * nothing of the payment was captured.
+ */
+const planCartPaymentVoid = (cartCollection, orders) => {
+    const cartPayment = getCartPayment(cartCollection);
+    if (!cartCollection ||
+        !cartPayment ||
+        !orders.length ||
+        (0, exports.isPaymentCaptured)(cartPayment) ||
+        !orders.every(exports.isOrderCanceled)) {
+        return { payment_ids: [], payment_collection_ids: [] };
+    }
+    return {
+        payment_ids: [cartPayment.id],
+        payment_collection_ids: [cartCollection.id],
+    };
+};
+exports.planCartPaymentVoid = planCartPaymentVoid;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"split-order-payment-group.js","sourceRoot":"","sources":["../../../../../../src/workflows/payment/utils/split-order-payment-group.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/workflows/payment/utils/split-order-payment.d.ts

@@ -0,0 +1,15 @@
+import { BigNumberInput } from "@medusajs/framework/types";
+import { MathBN } from "@medusajs/framework/utils";
+type BigNumberValue = ReturnType<typeof MathBN.convert>;
+export declare const getCurrencyDecimalDigits: (currencyCode?: string | null) => number;
+/**
+ * Splits `amount` across `weights` proportionally. Shares are rounded down to
+ * the currency precision and the remainder is handed out one minor unit at a
+ * time to the largest fractions, so the shares always sum exactly to `amount`.
+ */
+export declare const allocateProportionally: ({ amount, weights, decimalDigits, }: {
+    amount: BigNumberInput;
+    weights: BigNumberInput[];
+    decimalDigits: number;
+}) => BigNumberValue[];
+export {};

package/.medusa/server/src/workflows/payment/utils/split-order-payment.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allocateProportionally = exports.getCurrencyDecimalDigits = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const DEFAULT_DECIMAL_DIGITS = 2;
+const getCurrencyDecimalDigits = (currencyCode) => {
+    const currency = utils_1.defaultCurrencies[(currencyCode ?? "").toUpperCase()];
+    return currency?.decimal_digits ?? DEFAULT_DECIMAL_DIGITS;
+};
+exports.getCurrencyDecimalDigits = getCurrencyDecimalDigits;
+const floorTo = (value, decimalDigits) => {
+    const rounded = utils_1.MathBN.convert(value, decimalDigits);
+    if (utils_1.MathBN.lte(rounded, value)) {
+        return rounded;
+    }
+    return utils_1.MathBN.sub(rounded, utils_1.MathBN.div(1, utils_1.MathBN.convert(10).pow(decimalDigits)));
+};
+/**
+ * Splits `amount` across `weights` proportionally. Shares are rounded down to
+ * the currency precision and the remainder is handed out one minor unit at a
+ * time to the largest fractions, so the shares always sum exactly to `amount`.
+ */
+const allocateProportionally = ({ amount, weights, decimalDigits, }) => {
+    if (!weights.length) {
+        return [];
+    }
+    const total = utils_1.MathBN.convert(amount);
+    const positiveWeights = weights.map((weight) => utils_1.MathBN.max(utils_1.MathBN.convert(weight), 0));
+    const weightSum = positiveWeights.reduce((acc, weight) => utils_1.MathBN.add(acc, weight), utils_1.MathBN.convert(0));
+    const effectiveWeights = utils_1.MathBN.gt(weightSum, 0)
+        ? positiveWeights
+        : positiveWeights.map(() => utils_1.MathBN.convert(1));
+    const effectiveSum = utils_1.MathBN.gt(weightSum, 0)
+        ? weightSum
+        : utils_1.MathBN.convert(effectiveWeights.length);
+    const unit = utils_1.MathBN.div(1, utils_1.MathBN.convert(10).pow(decimalDigits));
+    const exact = effectiveWeights.map((weight) => utils_1.MathBN.div(utils_1.MathBN.mult(total, weight), effectiveSum));
+    const shares = exact.map((share) => floorTo(share, decimalDigits));
+    let leftover = utils_1.MathBN.sub(total, shares.reduce((acc, share) => utils_1.MathBN.add(acc, share), utils_1.MathBN.convert(0)));
+    const byLargestFraction = exact
+        .map((share, index) => ({
+        index,
+        fraction: utils_1.MathBN.sub(share, shares[index]),
+    }))
+        .sort((a, b) => utils_1.MathBN.eq(a.fraction, b.fraction)
+        ? a.index - b.index
+        : utils_1.MathBN.gt(a.fraction, b.fraction)
+            ? -1
+            : 1);
+    for (const { index } of byLargestFraction) {
+        if (utils_1.MathBN.lt(leftover, unit)) {
+            break;
+        }
+        shares[index] = utils_1.MathBN.add(shares[index], unit);
+        leftover = utils_1.MathBN.sub(leftover, unit);
+    }
+    // Only reachable when `amount` itself is finer than the currency precision.
+    if (utils_1.MathBN.gt(leftover, 0)) {
+        const { index } = byLargestFraction[0];
+        shares[index] = utils_1.MathBN.add(shares[index], leftover);
+    }
+    return shares;
+};
+exports.allocateProportionally = allocateProportionally;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsaXQtb3JkZXItcGF5bWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcGF5bWVudC91dGlscy9zcGxpdC1vcmRlci1wYXltZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHFEQUFxRTtBQUlyRSxNQUFNLHNCQUFzQixHQUFHLENBQUMsQ0FBQTtBQUV6QixNQUFNLHdCQUF3QixHQUFHLENBQUMsWUFBNEIsRUFBRSxFQUFFO0lBQ3ZFLE1BQU0sUUFBUSxHQUFHLHlCQUFpQixDQUFDLENBQUMsWUFBWSxJQUFJLEVBQUUsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUE7SUFDdEUsT0FBTyxRQUFRLEVBQUUsY0FBYyxJQUFJLHNCQUFzQixDQUFBO0FBQzNELENBQUMsQ0FBQTtBQUhZLFFBQUEsd0JBQXdCLDRCQUdwQztBQUVELE1BQU0sT0FBTyxHQUFHLENBQUMsS0FBcUIsRUFBRSxhQUFxQixFQUFFLEVBQUU7SUFDL0QsTUFBTSxPQUFPLEdBQUcsY0FBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsYUFBYSxDQUFDLENBQUE7SUFDcEQsSUFBSSxjQUFNLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQy9CLE9BQU8sT0FBTyxDQUFBO0lBQ2hCLENBQUM7SUFDRCxPQUFPLGNBQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLGNBQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGNBQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUNsRixDQUFDLENBQUE7QUFFRDs7OztHQUlHO0FBQ0ksTUFBTSxzQkFBc0IsR0FBRyxDQUFDLEVBQ3JDLE1BQU0sRUFDTixPQUFPLEVBQ1AsYUFBYSxHQUtkLEVBQW9CLEVBQUU7SUFDckIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNwQixPQUFPLEVBQUUsQ0FBQTtJQUNYLENBQUM7SUFFRCxNQUFNLEtBQUssR0FBRyxjQUFNLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ3BDLE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUM3QyxjQUFNLENBQUMsR0FBRyxDQUFDLGNBQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQ3RDLENBQUE7SUFDRCxNQUFNLFNBQVMsR0FBRyxlQUFlLENBQUMsTUFBTSxDQUN0QyxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDLGNBQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUN4QyxjQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUNsQixDQUFBO0lBQ0QsTUFBTSxnQkFBZ0IsR0FBRyxjQUFNLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFDOUMsQ0FBQyxDQUFDLGVBQWU7UUFDakIsQ0FBQyxDQUFDLGVBQWUsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsY0FBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2hELE1BQU0sWUFBWSxHQUFHLGNBQU0sQ0FBQyxFQUFFLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQztRQUMxQyxDQUFDLENBQUMsU0FBUztRQUNYLENBQUMsQ0FBQyxjQUFNLENBQUMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRTNDLE1BQU0sSUFBSSxHQUFHLGNBQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLGNBQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUE7SUFDakUsTUFBTSxLQUFLLEdBQUcsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FDNUMsY0FBTSxDQUFDLEdBQUcsQ0FBQyxjQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsRUFBRSxZQUFZLENBQUMsQ0FDckQsQ0FBQTtJQUNELE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQTtJQUVsRSxJQUFJLFFBQVEsR0FBRyxjQUFNLENBQUMsR0FBRyxDQUN2QixLQUFLLEVBQ0wsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLGNBQU0sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxFQUFFLGNBQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FDekUsQ0FBQTtJQUVELE1BQU0saUJBQWlCLEdBQUcsS0FBSztTQUM1QixHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3RCLEtBQUs7UUFDTCxRQUFRLEVBQUUsY0FBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0tBQzNDLENBQUMsQ0FBQztTQUNGLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUNiLGNBQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsUUFBUSxDQUFDO1FBQy9CLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxLQUFLO1FBQ25CLENBQUMsQ0FBQyxjQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLFFBQVEsQ0FBQztZQUNuQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ0osQ0FBQyxDQUFDLENBQUMsQ0FDTixDQUFBO0lBRUgsS0FBSyxNQUFNLEVBQUUsS0FBSyxFQUFFLElBQUksaUJBQWlCLEVBQUUsQ0FBQztRQUMxQyxJQUFJLGNBQU0sQ0FBQyxFQUFFLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDOUIsTUFBSztRQUNQLENBQUM7UUFDRCxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsY0FBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUE7UUFDL0MsUUFBUSxHQUFHLGNBQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFBO0lBQ3ZDLENBQUM7SUFFRCw0RUFBNEU7SUFDNUUsSUFBSSxjQUFNLENBQUMsRUFBRSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzNCLE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUN0QyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsY0FBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFDckQsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFBO0FBQ2YsQ0FBQyxDQUFBO0FBbkVZLFFBQUEsc0JBQXNCLDBCQW1FbEMifQ==

package/.medusa/server/src/workflows/payment/workflows/index.d.ts

@@ -1 +1,3 @@
 export * from "./process-payment";
+export * from "./payment-hooks";
+export * from "./split-order-payments";

package/.medusa/server/src/workflows/payment/workflows/index.js

@@ -15,4 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./process-payment"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUMifQ==
+__exportStar(require("./payment-hooks"), exports);
+__exportStar(require("./split-order-payments"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3BheW1lbnQvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxvREFBaUM7QUFDakMsa0RBQStCO0FBQy9CLHlEQUFzQyJ9

package/.medusa/server/src/workflows/payment/workflows/payment-hooks.d.ts

@@ -0,0 +1,25 @@
+import type { BigNumberInput, PaymentDTO } from "@medusajs/framework/types";
+import type { Hook, ReturnWorkflow } from "@medusajs/framework/workflows-sdk";
+import { type CapturePaymentWorkflowInput, type RefundPaymentWorkflowInput } from "@medusajs/medusa/core-flows";
+export type CapturePaymentWorkflowHooks = [
+    Hook<"paymentCaptured", {
+        payment: PaymentDTO;
+        order_id: string | null;
+        amount: BigNumberInput | null;
+    }, unknown>
+];
+export type RefundPaymentWorkflowHooks = [
+    Hook<"paymentRefunded", {
+        payment: PaymentDTO;
+        order_id: string | null;
+        amount: BigNumberInput | null;
+        credit_line_amount: BigNumberInput;
+        refund_reason: {
+            id: string;
+            label: string;
+            code: string | null;
+        } | null;
+    }, unknown>
+];
+export declare const capturePaymentWorkflow: ReturnWorkflow<CapturePaymentWorkflowInput, PaymentDTO, CapturePaymentWorkflowHooks>;
+export declare const refundPaymentWorkflow: ReturnWorkflow<RefundPaymentWorkflowInput, PaymentDTO, RefundPaymentWorkflowHooks>;

package/.medusa/server/src/workflows/payment/workflows/payment-hooks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refundPaymentWorkflow = exports.capturePaymentWorkflow = void 0;
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+// The hooks come from the core-flows payment-hooks patch, which is applied in
+// memory and cannot reach Medusa's shipped typings, so the patched shape is
+// asserted here. Keep in sync with patches/@medusajs+core-flows@*-payment-hooks.patch.
+exports.capturePaymentWorkflow = core_flows_1.capturePaymentWorkflow;
+exports.refundPaymentWorkflow = core_flows_1.refundPaymentWorkflow;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bWVudC1ob29rcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy93b3JrZmxvd3MvcGF5bWVudC93b3JrZmxvd3MvcGF5bWVudC1ob29rcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSw0REFLb0M7QUE0QnBDLDhFQUE4RTtBQUM5RSw0RUFBNEU7QUFDNUUsdUZBQXVGO0FBQzFFLFFBQUEsc0JBQXNCLEdBQ2pDLG1DQUlDLENBQUE7QUFFVSxRQUFBLHFCQUFxQixHQUNoQyxrQ0FJQyxDQUFBIn0=

package/.medusa/server/src/workflows/payment/workflows/split-order-payments.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The cart whose payment to split.
+ */
+export type SplitCapturedCartPaymentWorkflowInput = {
+    /**
+     * The ID of the cart.
+     */
+    cart_id: string;
+};
+export declare const splitCapturedCartPaymentWorkflowId = "split-captured-cart-payment";
+/**
+ * This workflow splits a captured cart payment between the orders of the
+ * cart. Every order gets a payment collection of its own, linked to the order,
+ * with a captured payment for the order's share on the cart payment's provider
+ * and pointing at the same charge, so Medusa's refund and cancel workflows
+ * apply to the order. What was charged for orders canceled before the capture
+ * is refunded against the cart payment.
+ *
+ * The workflow only adds what is missing: it does nothing until the cart
+ * payment has a capture, and nothing when run again for the same capture.
+ *
+ * @example
+ * const { result } = await splitCapturedCartPaymentWorkflow(container)
+ * .run({
+ *   input: {
+ *     cart_id: "cart_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Split a captured cart payment into a payment per order.
+ */
+export declare const splitCapturedCartPaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<SplitCapturedCartPaymentWorkflowInput, import("@medusajs/types").PaymentDTO[], []>;
+/**
+ * The cart whose payment to void.
+ */
+export type VoidCanceledCartPaymentWorkflowInput = {
+    /**
+     * The ID of the cart.
+     */
+    cart_id: string;
+};
+export declare const voidCanceledCartPaymentWorkflowId = "void-canceled-cart-payment";
+/**
+ * This workflow voids a cart's payment once every order of the cart is
+ * canceled. Until it is captured, the authorization is shared by the cart's
+ * orders, so canceling a single order leaves it in place. The workflow does
+ * nothing while an order is still open or once the payment is captured.
+ *
+ * @example
+ * const { result } = await voidCanceledCartPaymentWorkflow(container)
+ * .run({
+ *   input: {
+ *     cart_id: "cart_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Void a cart's payment when all of its orders are canceled.
+ */
+export declare const voidCanceledCartPaymentWorkflow: import("@medusajs/framework/workflows-sdk").ReturnWorkflow<VoidCanceledCartPaymentWorkflowInput, {
+    payment_ids: string[];
+    payment_collection_ids: string[];
+}, []>;