order-management 0.0.74 → 0.0.76

package/.medusa/server/src/workflows/steps/transform-order-to-cart-step.js

@@ -1,14 +1,203 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformOrderToCartStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
 const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
-exports.transformOrderToCartStep = (0, workflows_sdk_1.createStep)("transform-order-to-cart", async (input) => {
-    const { order } = input;
+const getVariantAvailableQuantity = (variant) => {
+    const directQuantity = [
+        variant.calculated_inventory_quantity,
+        variant.inventory_quantity,
+    ].find((quantity) => typeof quantity === "number");
+    if (typeof directQuantity === "number") {
+        return directQuantity;
+    }
+    const inventoryItems = variant.inventory_items ?? [];
+    if (!inventoryItems.length) {
+        return null;
+    }
+    // For variants linked to multiple inventory items, sellable quantity is
+    // limited by the "bottleneck" item after accounting for required quantity.
+    const availableByItem = inventoryItems
+        .map((item) => {
+        const requiredQuantity = typeof item.required_quantity === "number" && item.required_quantity > 0
+            ? item.required_quantity
+            : 1;
+        const levels = item.inventory?.location_levels ?? [];
+        const totalAvailable = levels.reduce((sum, level) => {
+            if (typeof level.available_quantity === "number") {
+                return sum + level.available_quantity;
+            }
+            if (typeof level.stocked_quantity === "number" &&
+                typeof level.reserved_quantity === "number") {
+                return sum + (level.stocked_quantity - level.reserved_quantity);
+            }
+            return sum;
+        }, 0);
+        return Math.floor(totalAvailable / requiredQuantity);
+    })
+        .filter((value) => Number.isFinite(value));
+    if (!availableByItem.length) {
+        return null;
+    }
+    return Math.min(...availableByItem);
+};
+exports.transformOrderToCartStep = (0, workflows_sdk_1.createStep)("transform-order-to-cart", async (input, { container }) => {
+    const { order, force_reorder = false } = input;
+    const variantDetailsById = new Map();
+    for (const item of order.items || []) {
+        if (!item.variant_id || variantDetailsById.has(item.variant_id)) {
+            continue;
+        }
+        const orderItem = item;
+        variantDetailsById.set(item.variant_id, {
+            variant_name: orderItem.variant_title ?? null,
+            product_name: orderItem.product_title ?? null,
+        });
+    }
     // Map order items to cart items
     const items = (order.items || []).map((item) => ({
         variant_id: item.variant_id,
         quantity: item.quantity,
     }));
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const requestedQuantityByVariant = new Map();
+    for (const item of items) {
+        if (!item.variant_id) {
+            continue;
+        }
+        const existingQuantity = requestedQuantityByVariant.get(item.variant_id) ?? 0;
+        requestedQuantityByVariant.set(item.variant_id, existingQuantity + item.quantity);
+    }
+    const variantIds = Array.from(requestedQuantityByVariant.keys());
+    if (!variantIds.length) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Cannot reorder: no valid variants found in order items.");
+    }
+    const { data: variants } = await query.graph({
+        entity: "product_variant",
+        fields: [
+            "id",
+            "inventory_quantity",
+            "calculated_inventory_quantity",
+            "allow_backorder",
+            "manage_inventory",
+            "inventory_items.required_quantity",
+            "inventory_items.inventory.location_levels.available_quantity",
+            "inventory_items.inventory.location_levels.stocked_quantity",
+            "inventory_items.inventory.location_levels.reserved_quantity",
+        ],
+        filters: {
+            id: variantIds,
+        },
+    });
+    const variantsById = new Map();
+    for (const variant of variants) {
+        variantsById.set(variant.id, variant);
+    }
+    const inventoryIssues = [];
+    const forceModeSkippedIssues = [];
+    const maxAllowedByVariant = new Map();
+    for (const [variantId, requestedQuantity] of requestedQuantityByVariant.entries()) {
+        const variant = variantsById.get(variantId);
+        const variantDetails = variantDetailsById.get(variantId);
+        if (!variant) {
+            const issue = {
+                variant_id: variantId,
+                variant_name: variantDetails?.variant_name ?? null,
+                product_name: variantDetails?.product_name ?? null,
+                requested_quantity: requestedQuantity,
+                available_quantity: null,
+                reason: "Variant not found",
+            };
+            inventoryIssues.push(issue);
+            forceModeSkippedIssues.push(issue);
+            continue;
+        }
+        // If inventory management is explicitly disabled or backorders are explicitly allowed,
+        // this variant should not block reorder creation.
+        if (variant.manage_inventory === false || variant.allow_backorder === true) {
+            maxAllowedByVariant.set(variantId, requestedQuantity);
+            continue;
+        }
+        const availableQuantity = getVariantAvailableQuantity(variant);
+        if (availableQuantity === null) {
+            const issue = {
+                variant_id: variantId,
+                variant_name: variantDetails?.variant_name ?? null,
+                product_name: variantDetails?.product_name ?? null,
+                requested_quantity: requestedQuantity,
+                available_quantity: null,
+                reason: "Inventory quantity is unavailable",
+            };
+            inventoryIssues.push(issue);
+            forceModeSkippedIssues.push(issue);
+            continue;
+        }
+        if (availableQuantity <= 0) {
+            const issue = {
+                variant_id: variantId,
+                variant_name: variantDetails?.variant_name ?? null,
+                product_name: variantDetails?.product_name ?? null,
+                requested_quantity: requestedQuantity,
+                available_quantity: availableQuantity,
+                reason: "Out of stock",
+            };
+            inventoryIssues.push(issue);
+            forceModeSkippedIssues.push(issue);
+            continue;
+        }
+        maxAllowedByVariant.set(variantId, Math.min(requestedQuantity, Math.floor(availableQuantity)));
+        if (availableQuantity < requestedQuantity) {
+            inventoryIssues.push({
+                variant_id: variantId,
+                variant_name: variantDetails?.variant_name ?? null,
+                product_name: variantDetails?.product_name ?? null,
+                requested_quantity: requestedQuantity,
+                available_quantity: availableQuantity,
+                reason: availableQuantity <= 0 ? "Out of stock" : "Insufficient inventory",
+            });
+        }
+    }
+    if (!force_reorder && inventoryIssues.length) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Inventory check failed for reorder items: ${JSON.stringify(inventoryIssues)}`);
+    }
+    const finalItems = force_reorder
+        ? (() => {
+            const remainingByVariant = new Map(maxAllowedByVariant);
+            const adjustedItems = [];
+            for (const item of items) {
+                const remaining = remainingByVariant.get(item.variant_id) ?? 0;
+                if (remaining <= 0) {
+                    continue;
+                }
+                const itemQuantity = Math.min(item.quantity, remaining);
+                if (itemQuantity <= 0) {
+                    continue;
+                }
+                adjustedItems.push({
+                    variant_id: item.variant_id,
+                    quantity: itemQuantity,
+                });
+                remainingByVariant.set(item.variant_id, remaining - itemQuantity);
+            }
+            return adjustedItems;
+        })()
+        : items;
+    if (force_reorder && finalItems.length === 0) {
+        const fallbackIssues = forceModeSkippedIssues.length > 0
+            ? forceModeSkippedIssues
+            : Array.from(requestedQuantityByVariant.entries()).map(([variantId, requestedQuantity]) => {
+                const variantDetails = variantDetailsById.get(variantId);
+                return {
+                    variant_id: variantId,
+                    variant_name: variantDetails?.variant_name ?? null,
+                    product_name: variantDetails?.product_name ?? null,
+                    requested_quantity: requestedQuantity,
+                    available_quantity: 0,
+                    reason: "Out of stock",
+                };
+            });
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Inventory check failed for reorder items: ${JSON.stringify(fallbackIssues)}`);
+    }
     // Extract billing address
     const billingAddress = order.billing_address
         ? {
@@ -44,10 +233,10 @@ exports.transformOrderToCartStep = (0, workflows_sdk_1.createStep)("transform-or
         email: order.email,
         billing_address: billingAddress,
         shipping_address: shippingAddress,
-        items,
+        items: finalItems,
     };
     return new workflows_sdk_1.StepResponse({
         cartInput,
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transform-order-to-cart-step.js","sourceRoot":"","sources":["../../../../../src/workflows/steps/transform-order-to-cart-step.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "order-management",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "description": "A starter for Medusa plugins.",
   "author": "Medusa (https://medusajs.com)",
   "license": "MIT",