@lodashventure/medusa-parcel-shipping 0.0.3

package/.medusa/server/src/modules/parcel-shipping/service.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const parcel_box_1 = require("./models/parcel-box");
+const shipping_rate_1 = require("./models/shipping-rate");
+const service_area_1 = require("./models/service-area");
+const packing_1 = require("./utils/packing");
+const CACHE_TTL_MS = 60_000;
+class ParcelShippingModuleService extends (0, utils_1.MedusaService)({
+    ParcelBox: parcel_box_1.ParcelBox,
+    ShippingRate: shipping_rate_1.ShippingRate,
+    ServiceArea: service_area_1.ServiceArea,
+}) {
+    constructor() {
+        super(...arguments);
+        this.cache = {
+            boxes: { data: null, expiresAt: 0 },
+            rates: { data: null, expiresAt: 0 },
+            areas: { data: null, expiresAt: 0 },
+        };
+    }
+    invalidateCache(keys) {
+        if (!keys || keys.length === 0) {
+            Object.keys(this.cache).forEach((key) => {
+                this.cache[key] = { data: null, expiresAt: 0 };
+            });
+            return;
+        }
+        for (const key of keys) {
+            this.cache[key] = { data: null, expiresAt: 0 };
+        }
+    }
+    async quote(input) {
+        if (!input.items?.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "At least one line item is required.");
+        }
+        if (!input.shipping_address) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Shipping address is required.");
+        }
+        const address = input.shipping_address;
+        if (address.country?.toUpperCase() !== "TH") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "country_not_supported");
+        }
+        const [boxes, rates, serviceAreas] = await Promise.all([
+            this.getActiveBoxes(),
+            this.getActiveRates(),
+            this.getActiveServiceAreas(),
+        ]);
+        if (!boxes.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "No active parcel boxes configured.");
+        }
+        const packing = (0, packing_1.selectBestPacking)(input.items, boxes);
+        if (!packing.success) {
+            return {
+                success: false,
+                failure: packing,
+            };
+        }
+        const totalWeight = packing.result.metrics.totalWeightKg;
+        const shippingQuote = this.resolveShippingQuote(address, totalWeight, rates, serviceAreas);
+        return {
+            success: true,
+            best_box: packing.result.box,
+            packing: packing.result.metrics,
+            shipping_quote: shippingQuote,
+        };
+    }
+    async getActiveBoxes() {
+        return this.readThroughCache("boxes", async () => {
+            const records = await this.listParcelBoxes({ active: true }, { order: { price_thb: "ASC" } });
+            return records.map((record) => ({
+                id: record.id,
+                name: record.name,
+                width_cm: Number(record.width_cm),
+                length_cm: Number(record.length_cm),
+                height_cm: Number(record.height_cm),
+                max_weight_kg: Number(record.max_weight_kg),
+                price_thb: Number(record.price_thb),
+            }));
+        });
+    }
+    async quoteShippingOnly(address, totalWeightKg) {
+        if (!address) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Shipping address is required.");
+        }
+        if (!totalWeightKg || !Number.isFinite(totalWeightKg) || totalWeightKg <= 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "A positive shipment weight in kilograms is required.");
+        }
+        const [rates, serviceAreas] = await Promise.all([
+            this.getActiveRates(),
+            this.getActiveServiceAreas(),
+        ]);
+        return this.resolveShippingQuote(address, Number(totalWeightKg.toFixed(4)), rates, serviceAreas);
+    }
+    async getActiveRates() {
+        return this.readThroughCache("rates", async () => {
+            const records = await this.listShippingRates({ active: true }, { order: { carrier: "ASC", max_weight_kg: "ASC" } });
+            return records.map((record) => ({
+                id: record.id,
+                carrier: record.carrier,
+                min_weight_kg: Number(record.min_weight_kg ?? 0),
+                max_weight_kg: Number(record.max_weight_kg),
+                price_thb: Number(record.price_thb),
+                currency: record.currency || "THB",
+            }));
+        });
+    }
+    async getActiveServiceAreas() {
+        return this.readThroughCache("areas", async () => {
+            const records = await this.listServiceAreas({ active: true }, { order: { kind: "ASC", value: "ASC" } });
+            return records.map((record) => ({
+                id: record.id,
+                kind: record.kind,
+                value: record.value,
+            }));
+        });
+    }
+    resolveShippingQuote(address, totalWeightKg, rates, areas) {
+        const inServiceArea = this.isInServiceArea(address, areas);
+        const carrier = inServiceArea
+            ? "COMPANY_TRUCK"
+            : "PRIVATE_CARRIER";
+        const carrierRates = rates
+            .filter((rate) => rate.carrier === carrier)
+            .sort((a, b) => a.max_weight_kg - b.max_weight_kg);
+        if (!carrierRates.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `rate_missing(${carrier})`);
+        }
+        const selectedRate = carrierRates.find((rate) => {
+            const min = rate.min_weight_kg ?? 0;
+            return totalWeightKg >= min && totalWeightKg <= rate.max_weight_kg;
+        });
+        if (!selectedRate) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `weight_slab_missing_${carrier}`);
+        }
+        return {
+            method: carrier,
+            area: inServiceArea ? "SERVICE_AREA" : "OUT_OF_AREA",
+            weightKg: Number(totalWeightKg.toFixed(3)),
+            price: selectedRate.price_thb,
+            currency: selectedRate.currency || "THB",
+        };
+    }
+    isInServiceArea(address, areas) {
+        const provinceNormalized = address.province.trim().toLowerCase();
+        const postcode = (address.postcode || "").trim();
+        return areas.some((area) => {
+            if (area.kind === "PROVINCE") {
+                return area.value.trim().toLowerCase() === provinceNormalized;
+            }
+            if (area.kind === "POSTCODE_PREFIX") {
+                return postcode.startsWith(area.value.trim());
+            }
+            return false;
+        });
+    }
+    async readThroughCache(key, loader) {
+        const entry = this.cache[key];
+        const now = Date.now();
+        if (entry.data && entry.expiresAt > now) {
+            return entry.data;
+        }
+        const data = await loader();
+        this.cache[key] = {
+            data,
+            expiresAt: now + CACHE_TTL_MS,
+        };
+        return data;
+    }
+}
+exports.default = ParcelShippingModuleService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/parcel-shipping/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/parcel-shipping/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9wYXJjZWwtc2hpcHBpbmcvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/.medusa/server/src/modules/parcel-shipping/utils/packing.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectBestPacking = selectBestPacking;
+const PADDING_PER_SIDE_CM = 2;
+const PADDING_TOTAL = PADDING_PER_SIDE_CM * 2;
+function selectBestPacking(items, boxes) {
+    const expandedItems = expandItems(items);
+    if (!expandedItems.length) {
+        return {
+            success: false,
+            code: "invalid_items",
+            message: "No items with positive quantity were provided.",
+        };
+    }
+    const successful = [];
+    const overweight = [];
+    const nearFits = [];
+    for (const box of boxes) {
+        const evaluation = evaluateBox(box, expandedItems);
+        if (evaluation.status === "success") {
+            successful.push(evaluation.evaluation);
+            continue;
+        }
+        if (evaluation.evaluation) {
+            if (evaluation.status === "overweight") {
+                overweight.push(evaluation.evaluation);
+            }
+            else if (evaluation.status === "no_fit") {
+                nearFits.push(evaluation.evaluation);
+            }
+        }
+    }
+    if (successful.length) {
+        const sorted = successful.sort(comparePacking);
+        return {
+            success: true,
+            result: sorted[0],
+        };
+    }
+    if (overweight.length) {
+        return {
+            success: false,
+            code: "no_fit_weight",
+            message: "Total weight exceeds the maximum weight limit for available boxes.",
+            alternatives: overweight.slice(0, 3).sort(comparePacking),
+        };
+    }
+    return {
+        success: false,
+        code: "no_fit",
+        message: "No configured box can fit the provided items.",
+        alternatives: nearFits.slice(0, 3).sort(comparePacking),
+    };
+}
+function evaluateBox(box, items) {
+    const totalActualWeight = items.reduce((acc, item) => acc + item.weight, 0);
+    const packedVolume = items.reduce((acc, item) => acc + item.volume, 0);
+    const initialMetrics = {
+        usedHeight: 0,
+        headroom: box.height_cm,
+        wasteAreaSum: box.width_cm * box.length_cm,
+        voidVolume: Math.max(box.width_cm * box.length_cm * box.height_cm - packedVolume, 0),
+        layers: 0,
+        placements: [],
+        totalWeightKg: Number(totalActualWeight.toFixed(4)),
+    };
+    if (totalActualWeight > box.max_weight_kg) {
+        return {
+            status: "overweight",
+            overBy: totalActualWeight - box.max_weight_kg,
+            evaluation: {
+                box,
+                metrics: initialMetrics,
+            },
+        };
+    }
+    const layers = [];
+    const sortedItems = items
+        .map((item) => ({ item }))
+        .sort((a, b) => b.item.volume - a.item.volume);
+    for (const { item } of sortedItems) {
+        const orientations = getOrientations(item, Boolean(item.attributes?.noStack));
+        let placed = false;
+        for (const orientation of orientations) {
+            for (const layer of layers) {
+                if (item.attributes?.noStack && layer.index !== 0) {
+                    continue;
+                }
+                const totalHeightIfPlaced = layers.reduce((acc, existingLayer) => acc +
+                    (existingLayer === layer
+                        ? Math.max(existingLayer.height, orientation.height)
+                        : existingLayer.height), 0);
+                if (totalHeightIfPlaced > box.height_cm + 1e-6) {
+                    continue;
+                }
+                const placement = placeInLayer(layer, orientation);
+                if (placement) {
+                    placed = true;
+                    layer.height = Math.max(layer.height, orientation.height);
+                    layer.hasNoStack =
+                        layer.hasNoStack || Boolean(item.attributes?.noStack);
+                    layer.placements.push({
+                        sku: item.sku,
+                        orientation,
+                        position: [placement.x, placement.y, layer.startHeight],
+                    });
+                    recalculateLayerHeights(layers);
+                    updateWasteArea(initialMetrics, layers);
+                    break;
+                }
+            }
+            if (placed) {
+                break;
+            }
+            const totalUsedHeight = layers.reduce((acc, layer) => acc + layer.height, 0);
+            if (totalUsedHeight + orientation.height > box.height_cm + 1e-6) {
+                continue;
+            }
+            if (item.attributes?.noStack && layers.length > 0) {
+                continue;
+            }
+            const newLayer = {
+                index: layers.length,
+                startHeight: totalUsedHeight,
+                height: orientation.height,
+                spaces: [
+                    {
+                        x: 0,
+                        y: 0,
+                        width: box.width_cm,
+                        length: box.length_cm,
+                    },
+                ],
+                placements: [],
+                hasNoStack: Boolean(item.attributes?.noStack),
+            };
+            const placement = placeInLayer(newLayer, orientation);
+            if (!placement) {
+                continue;
+            }
+            newLayer.placements.push({
+                sku: item.sku,
+                orientation,
+                position: [placement.x, placement.y, newLayer.startHeight],
+            });
+            layers.push(newLayer);
+            recalculateLayerHeights(layers);
+            updateWasteArea(initialMetrics, layers);
+            placed = true;
+            break;
+        }
+        if (!placed) {
+            return {
+                status: "no_fit",
+                slackScore: calculateSlackScore(box, items),
+                evaluation: {
+                    box,
+                    metrics: initialMetrics,
+                },
+            };
+        }
+    }
+    initialMetrics.layers = layers.length;
+    initialMetrics.usedHeight = layers.reduce((acc, layer) => acc + layer.height, 0);
+    initialMetrics.headroom = Number(Math.max(box.height_cm - initialMetrics.usedHeight, 0).toFixed(2));
+    initialMetrics.placements = layers.flatMap((layer, layerIdx) => layer.placements.map((placement) => ({
+        sku: placement.sku,
+        orientation: [
+            Number(placement.orientation.width.toFixed(2)),
+            Number(placement.orientation.length.toFixed(2)),
+            Number(placement.orientation.height.toFixed(2)),
+        ],
+        position: placement.position,
+        layerIndex: layerIdx,
+    })));
+    initialMetrics.wasteAreaSum = layers.reduce((acc, layer) => acc +
+        layer.spaces.reduce((spaceAcc, space) => {
+            return spaceAcc + space.width * space.length;
+        }, 0), 0);
+    return {
+        status: "success",
+        evaluation: {
+            box,
+            metrics: initialMetrics,
+        },
+    };
+}
+function expandItems(items) {
+    const expanded = [];
+    for (const item of items) {
+        const qty = Math.max(0, Math.floor(item.quantity));
+        if (!qty) {
+            continue;
+        }
+        const paddedWidth = item.width + PADDING_TOTAL;
+        const paddedLength = item.length + PADDING_TOTAL;
+        const paddedHeight = item.height + PADDING_TOTAL;
+        const volume = paddedWidth * paddedLength * paddedHeight;
+        for (let i = 0; i < qty; i++) {
+            expanded.push({
+                sku: item.sku,
+                baseWidth: item.width,
+                baseLength: item.length,
+                baseHeight: item.height,
+                width: paddedWidth,
+                length: paddedLength,
+                height: paddedHeight,
+                weight: item.weight,
+                volume,
+                attributes: item.attributes,
+            });
+        }
+    }
+    return expanded;
+}
+function getOrientations(item, noStack) {
+    const orientations = [];
+    const dims = [item.width, item.length, item.height];
+    const permutations = [
+        [dims[0], dims[1], dims[2]],
+        [dims[0], dims[2], dims[1]],
+        [dims[1], dims[0], dims[2]],
+        [dims[1], dims[2], dims[0]],
+        [dims[2], dims[0], dims[1]],
+        [dims[2], dims[1], dims[0]],
+    ];
+    for (const [w, l, h] of permutations) {
+        if (noStack && h > Math.min(w, l)) {
+            continue;
+        }
+        orientations.push({
+            width: Number(w.toFixed(2)),
+            length: Number(l.toFixed(2)),
+            height: Number(h.toFixed(2)),
+            volume: Number((w * l * h).toFixed(2)),
+        });
+    }
+    return orientations.sort((a, b) => a.height - b.height || a.volume - b.volume);
+}
+function placeInLayer(layer, orientation) {
+    for (let i = 0; i < layer.spaces.length; i++) {
+        const space = layer.spaces[i];
+        if (orientation.width <= space.width + 1e-6 &&
+            orientation.length <= space.length + 1e-6) {
+            layer.spaces.splice(i, 1);
+            splitSpace(layer, space, orientation);
+            return {
+                x: space.x,
+                y: space.y,
+                width: orientation.width,
+                length: orientation.length,
+            };
+        }
+    }
+    return null;
+}
+function splitSpace(layer, space, orientation) {
+    const remainingWidth = Number(Math.max(space.width - orientation.width, 0).toFixed(2));
+    const remainingLength = Number(Math.max(space.length - orientation.length, 0).toFixed(2));
+    if (remainingWidth > 0) {
+        layer.spaces.push({
+            x: Number((space.x + orientation.width).toFixed(2)),
+            y: space.y,
+            width: remainingWidth,
+            length: orientation.length,
+        });
+    }
+    if (remainingLength > 0) {
+        layer.spaces.push({
+            x: space.x,
+            y: Number((space.y + orientation.length).toFixed(2)),
+            width: space.width,
+            length: remainingLength,
+        });
+    }
+}
+function recalculateLayerHeights(layers) {
+    let cursor = 0;
+    for (const layer of layers) {
+        layer.startHeight = Number(cursor.toFixed(2));
+        cursor += layer.height;
+    }
+}
+function updateWasteArea(metrics, layers) {
+    metrics.wasteAreaSum = layers.reduce((acc, layer) => {
+        return (acc +
+            layer.spaces.reduce((spaceAcc, space) => {
+                return spaceAcc + space.width * space.length;
+            }, 0));
+    }, 0);
+}
+function calculateSlackScore(box, items) {
+    const totalVolume = items.reduce((acc, item) => acc + item.volume, 0);
+    const boxVolume = box.width_cm * box.length_cm * box.height_cm;
+    const volumeSlack = boxVolume - totalVolume;
+    const maxWidth = Math.max(...items.map((item) => item.width));
+    const maxLength = Math.max(...items.map((item) => item.length));
+    const totalHeight = items.reduce((acc, item) => acc + item.height, 0);
+    const widthSlack = box.width_cm - maxWidth;
+    const lengthSlack = box.length_cm - maxLength;
+    const heightSlack = box.height_cm - totalHeight;
+    return ((volumeSlack > 0 ? volumeSlack : Number.MAX_SAFE_INTEGER) +
+        (widthSlack > 0 ? widthSlack : Number.MAX_SAFE_INTEGER / 2) +
+        (lengthSlack > 0 ? lengthSlack : Number.MAX_SAFE_INTEGER / 2) +
+        (heightSlack > 0 ? heightSlack : Number.MAX_SAFE_INTEGER / 2));
+}
+function comparePacking(a, b) {
+    if (a.metrics.usedHeight !== b.metrics.usedHeight) {
+        return a.metrics.usedHeight - b.metrics.usedHeight;
+    }
+    if (a.metrics.wasteAreaSum !== b.metrics.wasteAreaSum) {
+        return a.metrics.wasteAreaSum - b.metrics.wasteAreaSum;
+    }
+    if (a.metrics.voidVolume !== b.metrics.voidVolume) {
+        return a.metrics.voidVolume - b.metrics.voidVolume;
+    }
+    return a.box.price_thb - b.box.price_thb;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"packing.js","sourceRoot":"","sources":["../../../../../../src/modules/parcel-shipping/utils/packing.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/providers/company-truck/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanyTruckFulfillmentProvider = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const parcel_fulfillment_base_1 = require("../parcel-fulfillment-base");
+class CompanyTruckFulfillmentProvider extends parcel_fulfillment_base_1.ParcelFulfillmentProviderBase {
+    constructor(deps, options = {}) {
+        super(deps, options);
+        this.carrier = "COMPANY_TRUCK";
+        this.optionId = "parcel-company-truck";
+        this.optionLabel = "Company Truck Delivery";
+    }
+}
+exports.CompanyTruckFulfillmentProvider = CompanyTruckFulfillmentProvider;
+CompanyTruckFulfillmentProvider.identifier = "parcel-company-truck";
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.FULFILLMENT, {
+    services: [CompanyTruckFulfillmentProvider],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL2NvbXBhbnktdHJ1Y2svaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscURBQW1FO0FBRW5FLHdFQUEwRTtBQUUxRSxNQUFhLCtCQUNYLFNBQVEsdURBQTZCO0lBUXJDLFlBQ0UsSUFBb0UsRUFDcEUsVUFBNEMsRUFBRTtRQUU5QyxLQUFLLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFBO1FBUkgsWUFBTyxHQUFHLGVBQXdCLENBQUE7UUFDbEMsYUFBUSxHQUFHLHNCQUFzQixDQUFBO1FBQ2pDLGdCQUFXLEdBQUcsd0JBQXdCLENBQUE7SUFPekQsQ0FBQzs7QUFkSCwwRUFlQztBQVpRLDBDQUFVLEdBQUcsc0JBQXNCLEFBQXpCLENBQXlCO0FBYzVDLGtCQUFlLElBQUEsc0JBQWMsRUFBQyxlQUFPLENBQUMsV0FBVyxFQUFFO0lBQ2pELFFBQVEsRUFBRSxDQUFDLCtCQUErQixDQUFDO0NBQzVDLENBQUMsQ0FBQSJ9