@rytass/wms-module-core 0.1.0

package/lib/services/ship-inventory-order.service.js

@@ -0,0 +1,599 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { ShipInventoryOrderEntity } from '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import { ShipInventoryOrderItemEntity } from '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import { DataSource, IsNull, In } from 'typeorm';
+import { ShipInventoryOrderStatus } from '../typings/find-ship-inventory-order.input.js';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import '../models/metadata/batch.entity.js';
+import '../models/metadata/batch-group.entity.js';
+import '../models/metadata/loader.entity.js';
+import '../models/metadata/loader-type.entity.js';
+import '../models/metadata/loader-unit.entity.js';
+import '../models/metadata/location.entity.js';
+import { MaterialEntityClass } from '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import { SaleOrderEntity } from '../models/metadata/sale-order.entity.js';
+import { StockEntityClass } from '../models/metadata/stock.entity.js';
+import '../models/metadata/unit.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-item.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order.entity.js';
+import '../models/extensions/receive-inventory-order/receive-inventory-order-change.entity.js';
+import { ShipInventoryOrderReferenceEntity } from '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import { ShipInventoryOrderChangeEntityClass } from '../models/extensions/ship-inventory-order/ship-inventory-order-change.entity.js';
+import '../models/extensions/transfer-order/transfer-order.entity.js';
+import '../models/extensions/transfer-order/transfer-order-item.entity.js';
+import '../models/extensions/transfer-order/transfer-order-change.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order-item.entity.js';
+import '../models/extensions/hold-inventory-order/hold-inventory-order-change.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
+import '../models/extensions/allocate-inventory-order/allocate-inventory-order-change.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-item.entity.js';
+import '../models/extensions/split-batch-order/split-batch-order-change.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-item.entity.js';
+import '../models/extensions/merge-batch-order/merge-batch-order-change.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-item.entity.js';
+import '../models/extensions/reclassify-inventory-order/reclassify-inventory-order-change.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-item.entity.js';
+import '../models/extensions/transfer-vendor-order/transfer-vendor-order-change.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-item.entity.js';
+import '../models/extensions/quality-inspection-order/quality-inspection-order-change.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-item.entity.js';
+import '../models/extensions/transfer-customer-order/transfer-customer-order-change.entity.js';
+import '../models/extensions/scrape-order/scrape-order.entity.js';
+import '../models/extensions/scrape-order/scrape-order-item.entity.js';
+import '../models/extensions/scrape-order/scrape-order-change.entity.js';
+import { MaterialService } from './material.service.js';
+import { BatchService } from './batch.service.js';
+import { StockService } from './stock.service.js';
+
+/**
+ * Service for managing ship inventory orders and their items
+ * Supports dynamic entity injection for customization
+ * T - Ship Inventory Order entity type
+ * K - Ship Inventory Order Item entity type
+ */
+let ShipInventoryOrderService = class ShipInventoryOrderService {
+    dataSource;
+    materialService;
+    batchService;
+    stockService;
+    shipInventoryOrderEntity;
+    shipInventoryOrderItemEntity;
+    shipInventoryOrderReferenceEntity;
+    saleOrderEntity;
+    selectQueryBuilder;
+    constructor(dataSource, materialService, batchService, stockService, shipInventoryOrderEntity, shipInventoryOrderItemEntity, shipInventoryOrderReferenceEntity, saleOrderEntity) {
+        this.dataSource = dataSource;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.stockService = stockService;
+        this.shipInventoryOrderEntity = shipInventoryOrderEntity;
+        this.shipInventoryOrderItemEntity = shipInventoryOrderItemEntity;
+        this.shipInventoryOrderReferenceEntity = shipInventoryOrderReferenceEntity;
+        this.saleOrderEntity = saleOrderEntity;
+        this.selectQueryBuilder = (alias) => {
+            return this.dataSource
+                .getRepository(this.shipInventoryOrderEntity)
+                .createQueryBuilder(alias)
+                .leftJoin((subQuery) => subQuery
+                .select(`CASE
+                  WHEN o."removedAt" IS NOT NULL THEN '${ShipInventoryOrderStatus.REMOVED}'
+                  WHEN COALESCE(change_sums.shippedsum, 0) >= COALESCE(target_sum.targetsum, 0) AND COALESCE(target_sum.targetsum, 0) > 0 THEN '${ShipInventoryOrderStatus.SHIPPED}'
+                  WHEN COALESCE(change_sums.shippedsum, 0) > 0 AND COALESCE(change_sums.shippedsum, 0) < COALESCE(target_sum.targetsum, 0) THEN '${ShipInventoryOrderStatus.PARTIAL_SHIPPED}'
+                  ELSE '${ShipInventoryOrderStatus.PENDING}'
+                END`, 'status')
+                .addSelect('o.id', 'orderid')
+                .from('ship_inventory_orders', 'o')
+                .leftJoin((sumQuery) => sumQuery
+                .select('i."orderId"', 'orderid')
+                .addSelect(`SUM(CAST(i."targetShippedQuantity" AS NUMERIC))`, 'targetsum')
+                .from('ship_inventory_order_items', 'i')
+                .groupBy('i."orderId"'), 'target_sum', 'target_sum.orderid = o.id')
+                .leftJoin((sumQuery) => sumQuery
+                .select('i."orderId"', 'orderid')
+                .addSelect(`SUM(CASE WHEN CAST(c."quantityChanged" AS NUMERIC) < 0 THEN ABS(CAST(c."quantityChanged" AS NUMERIC)) ELSE 0 END)`, 'shippedsum')
+                .from('ship_inventory_order_changes', 'c')
+                .innerJoin('ship_inventory_order_items', 'i', 'c."itemId" = i.id')
+                .groupBy('i."orderId"'), 'change_sums', 'change_sums.orderid = o.id'), 'order_status', `${alias}.id = order_status.orderid`)
+                .select('orders.id', 'id')
+                .addSelect('orders.key', 'key')
+                .addSelect('orders.description', 'description')
+                .addSelect('orders."createdBy"', 'createdBy')
+                .addSelect('orders."createdAt"', 'createdAt')
+                .addSelect('orders."removedAt"', 'removedAt')
+                .addSelect('order_status.status', `status`);
+        };
+    }
+    processShipInventoryOrderReferences(references, manager) {
+        const materialRepository = manager.getRepository(MaterialEntityClass);
+        const saleOrderRepository = manager.getRepository(this.saleOrderEntity);
+        return references.reduce(async (accPromise, reference) => {
+            const acc = await accPromise;
+            try {
+                const material = await materialRepository.findOneBy({
+                    key: reference.materialKey,
+                });
+                if (!material)
+                    return acc;
+                if (reference.saleId && reference.saleSerialId)
+                    await saleOrderRepository.save(saleOrderRepository.create({
+                        id: reference.saleId,
+                        serialId: reference.saleSerialId,
+                    }));
+                return [
+                    ...acc,
+                    {
+                        ...reference,
+                        materialId: material.id,
+                    },
+                ];
+            }
+            catch {
+                return acc;
+            }
+        }, Promise.resolve([]));
+    }
+    async processShipInventoryOrderItems(items, manager) {
+        const shipInventoryOrderItemRepository = manager.getRepository(this.shipInventoryOrderItemEntity);
+        const shipInventoryOrderChangeRepository = manager.getRepository(ShipInventoryOrderChangeEntityClass);
+        const orderRepository = manager.getRepository(OrderEntity);
+        const stockRepository = manager.getRepository(StockEntityClass);
+        await Promise.all(items.map(async (data) => {
+            // Ensure required fields are present
+            if (!data.batchId || !data.materialId)
+                return;
+            // Split batch first with inShipment flag to track shipment state
+            const splittedBatch = await this.batchService.splitBatch({
+                id: data.batchId,
+                inShipment: true,
+                manager,
+            });
+            // Save item with ORIGINAL batch id to maintain source state
+            const item = await shipInventoryOrderItemRepository.save(shipInventoryOrderItemRepository.create(data));
+            const base = await orderRepository.save(orderRepository.create());
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            await shipInventoryOrderChangeRepository.save(shipInventoryOrderChangeRepository.create({
+                itemId: item.id,
+                id: base.id,
+                quantityChanged: item.targetShippedQuantity * conversionFactor,
+            }));
+            // Stock movements track the shipment through splitted batch
+            await this.stockService.validateStockAvailability({
+                materialId: item.materialId,
+                batchId: item.batchId,
+                locationId: this.stockService.resolveLocationId(item.locationId),
+                loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                quantity: item.targetShippedQuantity * conversionFactor,
+            }, manager);
+            await stockRepository.save(stockRepository.create([
+                // deduct from original batch available stock
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: item.batchId, // original batch
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: -1 * item.targetShippedQuantity * conversionFactor,
+                },
+                // add to splitted batch in shipment state
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: splittedBatch.id, // splitted batch marked inShipment
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: item.targetShippedQuantity * conversionFactor,
+                },
+            ]));
+        }));
+    }
+    async createShipInventoryOrder({ manager = this.dataSource.manager, ...options }) {
+        const orderRepository = manager.getRepository(OrderEntity);
+        const shipInventoryOrderRepository = manager.getRepository(this.shipInventoryOrderEntity);
+        const shipInventoryOrderReferenceRepository = manager.getRepository(this.shipInventoryOrderReferenceEntity);
+        // create base order
+        const { id } = await orderRepository.save(orderRepository.create());
+        // create ship inventory order
+        const order = await shipInventoryOrderRepository.save(shipInventoryOrderRepository.create({ id, ...options }));
+        // create ship inventory order references
+        if (options.references && options.references.length > 0) {
+            const processedReferences = await this.processShipInventoryOrderReferences(options.references, manager);
+            if (processedReferences.length > 0) {
+                const references = shipInventoryOrderReferenceRepository.create(processedReferences.map((reference) => ({
+                    ...reference,
+                    orderId: order.id,
+                })));
+                await shipInventoryOrderReferenceRepository.save(references);
+            }
+        }
+        return order;
+    }
+    /**
+     * Update a ship inventory order and its items
+     * update existing item when id is provided, otherwise create new item, remove behaviour controlled by removedAt field
+     */
+    async updateShipInventoryOrder({ id, manager = this.dataSource.manager, ...options }) {
+        const shipInventoryOrderRepository = manager.getRepository(this.shipInventoryOrderEntity);
+        const shipInventoryOrderReferenceRepository = manager.getRepository(this.shipInventoryOrderReferenceEntity);
+        const shipInventoryOrderItemRepository = manager.getRepository(this.shipInventoryOrderItemEntity);
+        const materialRepository = manager.getRepository(MaterialEntityClass);
+        const order = await shipInventoryOrderRepository.findOneByOrFail({
+            id,
+            removedAt: IsNull(),
+        });
+        const { references, items, ...orderOptions } = options;
+        const updated = await shipInventoryOrderRepository.save(shipInventoryOrderRepository.create({
+            ...order,
+            ...orderOptions,
+        }));
+        if (references?.length) {
+            const newItems = [];
+            const existingItems = [];
+            const items = await shipInventoryOrderReferenceRepository.find({
+                where: { orderId: id, removedAt: IsNull() },
+            });
+            const itemSet = new Set(items.map((i) => i.id));
+            const results = await Promise.all((references || []).map(async (item) => {
+                let batch = null;
+                if (item.batchKey) {
+                    const material = await materialRepository.findOneByOrFail({
+                        key: item.materialKey,
+                    });
+                    batch = await this.batchService.getBatch({
+                        manager,
+                        materialId: material.id,
+                        key: item.batchKey,
+                    });
+                }
+                return { item, batch };
+            }));
+            // Now process results after all async operations are complete
+            results.forEach((result) => {
+                if (!result)
+                    return;
+                const { item, batch } = result;
+                if (!item.id)
+                    newItems.push({ ...item, batchId: batch?.id || null });
+                else if (itemSet.has(item.id))
+                    existingItems.push({ ...item, batchId: batch?.id || null });
+            });
+            if (newItems.length) {
+                const processedNewItems = await this.processShipInventoryOrderReferences(newItems, manager);
+                if (processedNewItems.length > 0) {
+                    await shipInventoryOrderReferenceRepository.save(shipInventoryOrderReferenceRepository.create(processedNewItems.map((item) => ({ ...item, orderId: id }))));
+                }
+            }
+            if (existingItems.length)
+                await shipInventoryOrderReferenceRepository.save(existingItems.map((item) => shipInventoryOrderReferenceRepository.create({
+                    ...item,
+                    id: item.id,
+                })));
+        }
+        if (items?.length) {
+            const newItems = [];
+            const existingItems = [];
+            await shipInventoryOrderItemRepository
+                .find({ where: { orderId: id, removedAt: IsNull() } })
+                .then((dbItems) => {
+                const itemSet = new Set(dbItems.map((i) => i.id));
+                items?.forEach((item) => {
+                    if (!item.id)
+                        newItems.push({ ...item, orderId: id });
+                    else if (itemSet.has(item.id))
+                        existingItems.push(item);
+                });
+            });
+            if (newItems.length)
+                await this.processShipInventoryOrderItems(newItems, manager);
+            if (existingItems.length)
+                await shipInventoryOrderItemRepository.save(existingItems.map((item) => shipInventoryOrderItemRepository.create({
+                    ...item,
+                    id: item.id,
+                })));
+        }
+        return updated;
+    }
+    /**
+     * Remove a ship inventory order
+     * Automatically cancels all remaining prepared (but not shipped) items to release stock
+     */
+    async removeShipInventoryOrder(id) {
+        return this.dataSource.transaction(async (manager) => {
+            const shipInventoryOrderRepository = manager.getRepository(this.shipInventoryOrderEntity);
+            const itemRepository = manager.getRepository(this.shipInventoryOrderItemEntity);
+            // Find order
+            const order = await shipInventoryOrderRepository.findOne({
+                where: { id },
+            });
+            if (!order || order.removedAt)
+                return false;
+            // Find all items with changes to calculate cancellable quantities
+            const items = await itemRepository.find({
+                where: { orderId: id },
+                relations: ['changes'],
+            });
+            // Build cancel inputs for items with remaining prepared quantity
+            const cancelInputs = [];
+            for (const item of items) {
+                const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+                const preparedQuantity = item.changes.reduce((sum, change) => {
+                    const qty = Number(change.quantityChanged);
+                    return qty > 0 ? sum + qty : sum;
+                }, 0);
+                const shippedQuantity = item.changes.reduce((sum, change) => {
+                    const qty = Number(change.quantityChanged);
+                    return qty < 0 ? sum + Math.abs(qty) : sum;
+                }, 0);
+                const cancellableQuantity = preparedQuantity - shippedQuantity;
+                if (cancellableQuantity > 0) {
+                    // Use base quantity (without conversion) since cancelShip will apply conversion
+                    cancelInputs.push({
+                        itemId: item.id,
+                        quantity: cancellableQuantity / conversionFactor,
+                    });
+                }
+            }
+            // Cancel all remaining prepared items
+            if (cancelInputs.length > 0) {
+                await this.cancelShipInternal(cancelInputs, manager);
+            }
+            // Mark order as removed
+            await shipInventoryOrderRepository.update({ id }, { removedAt: new Date() });
+            return true;
+        });
+    }
+    /**
+     * Internal cancel method that accepts a manager for transaction support
+     */
+    async cancelShipInternal(options, manager) {
+        const changeRepository = manager.getRepository(ShipInventoryOrderChangeEntityClass);
+        const itemRepository = manager.getRepository(this.shipInventoryOrderItemEntity);
+        const orderRepository = manager.getRepository(OrderEntity);
+        const stockRepository = manager.getRepository(StockEntityClass);
+        const items = await itemRepository.find({
+            where: { id: In(options.map((o) => o.itemId)) },
+            relations: ['changes'],
+        });
+        const itemMap = new Map(items.map((item) => [item.id, item]));
+        await Promise.all(options.map(async (option) => {
+            const item = itemMap.get(option.itemId);
+            if (!item)
+                return;
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            const preparedQuantity = item.changes.reduce((sum, change) => {
+                const qty = Number(change.quantityChanged);
+                return qty > 0 ? sum + qty : sum;
+            }, 0);
+            const shippedQuantity = item.changes.reduce((sum, change) => {
+                const qty = Number(change.quantityChanged);
+                return qty < 0 ? sum + Math.abs(qty) : sum;
+            }, 0);
+            const cancellableQuantity = preparedQuantity - shippedQuantity;
+            const cancelQuantity = option.quantity != null
+                ? option.quantity * conversionFactor
+                : cancellableQuantity;
+            if (cancellableQuantity - cancelQuantity < 0) {
+                throw new Error(`Cancel quantity exceeds prepared quantity for item ${option.itemId}`);
+            }
+            if (cancelQuantity <= 0)
+                return;
+            const inShipmentBatch = await this.batchService.splitBatch({
+                id: item.batchId,
+                inShipment: true,
+                manager,
+            });
+            const reverseOrder = await orderRepository.save(orderRepository.create());
+            await this.stockService.validateStockAvailability({
+                materialId: item.materialId,
+                batchId: inShipmentBatch.id,
+                locationId: this.stockService.resolveLocationId(item.locationId),
+                loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                quantity: cancelQuantity,
+            }, manager);
+            await Promise.all([
+                changeRepository.save(changeRepository.create({
+                    itemId: option.itemId,
+                    id: reverseOrder.id,
+                    quantityChanged: -1 * cancelQuantity,
+                })),
+                stockRepository.save(stockRepository.create([
+                    {
+                        orderId: reverseOrder.id,
+                        materialId: item.materialId,
+                        batchId: item.batchId,
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: cancelQuantity,
+                    },
+                    {
+                        orderId: reverseOrder.id,
+                        materialId: item.materialId,
+                        batchId: inShipmentBatch.id,
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: -1 * cancelQuantity,
+                    },
+                ])),
+            ]);
+        }));
+    }
+    async findMany(options) {
+        const queryBuilder = this.selectQueryBuilder('orders');
+        if (options.id)
+            queryBuilder.andWhere('orders.id = :id', { id: options.id });
+        if (options.createdBy)
+            queryBuilder.andWhere('orders."createdBy" ILIKE :createdBy', {
+                createdBy: `%${options.createdBy}%`,
+            });
+        if (options.description)
+            queryBuilder.andWhere('orders.description ILIKE :description', {
+                description: `%${options.description}%`,
+            });
+        if (options.dateRange)
+            queryBuilder.andWhere('orders."createdAt" BETWEEN :from AND :to', {
+                from: options.dateRange.from,
+                to: options.dateRange.to,
+            });
+        if (options.status)
+            queryBuilder.andWhere(`status = :status`, {
+                status: options.status,
+            });
+        if (options.statuses && options.statuses.length > 0)
+            queryBuilder.andWhere(`status IN (:...statuses)`, {
+                statuses: options.statuses,
+            });
+        if (options.materialKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM ship_inventory_order_items si_items
+          INNER JOIN materials si_mat ON si_mat.id = si_items."materialId"
+          WHERE si_items."orderId" = orders.id
+          AND si_mat.key ILIKE :materialKey
+        )`, { materialKey: `%${options.materialKey}%` });
+        if (options.batchKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM ship_inventory_order_items si_items
+          INNER JOIN batches si_batch ON si_batch.id = si_items."batchId"
+          WHERE si_items."orderId" = orders.id
+          AND si_batch.key ILIKE :batchKey
+        )`, { batchKey: `%${options.batchKey}%` });
+        if (options.locationKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM ship_inventory_order_items si_items
+          INNER JOIN locations si_loc ON si_loc.id = si_items."locationId"
+          WHERE si_items."orderId" = orders.id
+          AND si_loc.key ILIKE :locationKey
+        )`, { locationKey: `%${options.locationKey}%` });
+        if (options.loaderKey)
+            queryBuilder.andWhere(`EXISTS (
+          SELECT 1 FROM ship_inventory_order_items si_items
+          INNER JOIN loaders si_ldr ON si_ldr.id = si_items."loaderId"
+          WHERE si_items."orderId" = orders.id
+          AND si_ldr."serialId" ILIKE :loaderKey
+        )`, { loaderKey: `%${options.loaderKey}%` });
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`orders."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        const total = await queryBuilder.getCount();
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        const items = await queryBuilder.getRawMany();
+        return [items, total];
+    }
+    async addShipInventoryOrderItems(options, manager = this.dataSource.manager) {
+        const shipInventoryOrderRepository = manager.getRepository(this.shipInventoryOrderEntity);
+        const order = await shipInventoryOrderRepository.findOneByOrFail({
+            id: options.orderId,
+            removedAt: IsNull(),
+        });
+        if (options.items.length) {
+            const items = options.items.map((item) => ({
+                ...item,
+                orderId: options.orderId,
+            }));
+            await this.processShipInventoryOrderItems(items, manager);
+        }
+        return order;
+    }
+    ship(options) {
+        if (!Array.isArray(options))
+            options = [options];
+        return this.dataSource.transaction(async (manager) => {
+            const changeRepository = manager.getRepository(ShipInventoryOrderChangeEntityClass);
+            const itemRepository = manager.getRepository(this.shipInventoryOrderItemEntity);
+            const orderRepository = manager.getRepository(OrderEntity);
+            const stockRepository = manager.getRepository(StockEntityClass);
+            const items = await itemRepository.find({
+                where: { id: In(options.map((option) => option.itemId)) },
+                relations: ['changes'],
+            });
+            const itemMap = new Map(items.map((item) => [item.id, item]));
+            await Promise.all(options.map(async (option) => {
+                const item = itemMap.get(option.itemId);
+                if (!item)
+                    return;
+                const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+                const totalShipped = item.changes.reduce((sum, change) => {
+                    const qty = Number(change.quantityChanged);
+                    return qty < 0 ? sum + Math.abs(qty) : sum;
+                }, 0);
+                const remainingQuantity = conversionFactor * item.targetShippedQuantity - totalShipped;
+                if (remainingQuantity - option.quantity * conversionFactor < 0) {
+                    throw new Error(`Shipping quantity exceeds target for item ${option.itemId}`);
+                }
+                // Create splitted batch for ship completion
+                const shippedBatch = await this.batchService.splitBatch({
+                    id: item.batchId,
+                    inShipment: true,
+                    manager,
+                });
+                const newOrder = await orderRepository.save(orderRepository.create());
+                await this.stockService.validateStockAvailability({
+                    materialId: item.materialId,
+                    batchId: item.batchId,
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: option.quantity * conversionFactor,
+                }, manager);
+                await Promise.all([
+                    changeRepository.save(changeRepository.create({
+                        itemId: option.itemId,
+                        quantityChanged: -1 * option.quantity * conversionFactor,
+                        id: newOrder.id,
+                    })),
+                    stockRepository.save(stockRepository.create([
+                        {
+                            batchId: shippedBatch.id,
+                            materialId: item.materialId,
+                            locationId: this.stockService.resolveLocationId(item.locationId),
+                            loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                            quantity: -1 * option.quantity * conversionFactor,
+                            orderId: newOrder.id,
+                        },
+                    ])),
+                ]);
+            }));
+            return true;
+        });
+    }
+    /**
+     * Cancel prepared ship inventory order items
+     * Reverses the prepare step by moving stock from IN_SHIPMENT back to FREE
+     * Can only cancel prepared quantity that hasn't been shipped yet
+     * If quantity is not provided, cancels all remaining cancellable quantity
+     */
+    cancelShip(options) {
+        if (!Array.isArray(options))
+            options = [options];
+        return this.dataSource.transaction(async (manager) => {
+            await this.cancelShipInternal(options, manager);
+            return true;
+        });
+    }
+};
+ShipInventoryOrderService = __decorate([
+    Injectable(),
+    __param(4, Inject(ShipInventoryOrderEntity)),
+    __param(5, Inject(ShipInventoryOrderItemEntity)),
+    __param(6, Inject(ShipInventoryOrderReferenceEntity)),
+    __param(7, Inject(SaleOrderEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        MaterialService,
+        BatchService,
+        StockService, Object, Object, Object, Object])
+], ShipInventoryOrderService);
+
+export { ShipInventoryOrderService };

package/lib/services/split-batch-order.service.d.ts

@@ -0,0 +1,19 @@
+import { SplitBatchOrderEntityClass, SplitBatchOrderItemEntityClass } from '../models';
+import { DataSource, EntityTarget } from 'typeorm';
+import { SplitBatchInput } from '../typings/split-batch.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { HelperService } from './helper.service';
+import { StockService } from './stock.service';
+export declare class SplitBatchOrderService<T extends SplitBatchOrderEntityClass = SplitBatchOrderEntityClass, K extends SplitBatchOrderItemEntityClass = SplitBatchOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly helperService;
+    private readonly stockService;
+    readonly splitBatchOrderEntity: EntityTarget<T>;
+    readonly splitBatchOrderItemEntity: EntityTarget<K>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, materialService: MaterialService, batchService: BatchService, helperService: HelperService, stockService: StockService, splitBatchOrderEntity: EntityTarget<T>, splitBatchOrderItemEntity: EntityTarget<K>);
+    split(options: SplitBatchInput): Promise<T>;
+}