@rytass/wms-module-core 0.1.0

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

@@ -0,0 +1,299 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+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 '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.entity.js';
+import { StockEntity } 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 '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import '../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 { AllocateInventoryOrderEntity } from '../models/extensions/allocate-inventory-order/allocate-inventory-order.entity.js';
+import { AllocateInventoryOrderItemEntity } from '../models/extensions/allocate-inventory-order/allocate-inventory-order-item.entity.js';
+import { AllocateInventoryOrderChangeEntityClass } from '../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 { DataSource, Not, IsNull } from 'typeorm';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { HelperService } from './helper.service.js';
+import { MaterialService } from './material.service.js';
+import { BatchService } from './batch.service.js';
+import { StockService } from './stock.service.js';
+
+let AllocateInventoryOrderService = class AllocateInventoryOrderService {
+    dataSource;
+    helperService;
+    materialService;
+    batchService;
+    stockService;
+    allocateInventoryOrderEntity;
+    allocateInventoryOrderItemEntity;
+    stockEntity;
+    seqPrefix = 'AIO';
+    constructor(dataSource, helperService, materialService, batchService, stockService, allocateInventoryOrderEntity, allocateInventoryOrderItemEntity, stockEntity) {
+        this.dataSource = dataSource;
+        this.helperService = helperService;
+        this.materialService = materialService;
+        this.batchService = batchService;
+        this.stockService = stockService;
+        this.allocateInventoryOrderEntity = allocateInventoryOrderEntity;
+        this.allocateInventoryOrderItemEntity = allocateInventoryOrderItemEntity;
+        this.stockEntity = stockEntity;
+    }
+    getRepositories(manager) {
+        return {
+            allocateInventoryOrder: manager.getRepository(this.allocateInventoryOrderEntity),
+            allocateInventoryOrderItem: manager.getRepository(this.allocateInventoryOrderItemEntity),
+            allocateInventoryOrderChange: manager.getRepository(AllocateInventoryOrderChangeEntityClass),
+            order: manager.getRepository(OrderEntity),
+            stock: manager.getRepository(this.stockEntity),
+        };
+    }
+    async processAllocateInventoryOrderItems(items, manager) {
+        const repos = this.getRepositories(manager);
+        await Promise.all(items.map(async (data) => {
+            // Ensure required fields are present
+            if (!data.batchId || !data.materialId)
+                return;
+            // Split batch first with saleId/saleSerialId to track allocation state
+            const splittedBatch = await this.batchService.splitBatch({
+                id: data.batchId,
+                saleId: data.saleId,
+                saleSerialId: data.saleSerialId,
+                manager,
+            });
+            // Save item with ORIGINAL batch id to maintain source state
+            const item = await repos.allocateInventoryOrderItem.save(repos.allocateInventoryOrderItem.create(data));
+            const base = await repos.order.save({});
+            const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+            await repos.allocateInventoryOrderChange.save(repos.allocateInventoryOrderChange.create({
+                item,
+                order: base,
+                quantityChanged: item.targetAllocatedQuantity * conversionFactor,
+            }));
+            // Stock movements track the allocation 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.targetAllocatedQuantity * conversionFactor,
+            }, manager);
+            await repos.stock.save(repos.stock.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.targetAllocatedQuantity * conversionFactor,
+                },
+                // add to splitted batch in allocated state
+                {
+                    orderId: base.id,
+                    materialId: item.materialId,
+                    batchId: splittedBatch.id, // splitted batch marked with saleId
+                    locationId: this.stockService.resolveLocationId(item.locationId),
+                    loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                    quantity: item.targetAllocatedQuantity * conversionFactor,
+                },
+            ]));
+        }));
+    }
+    async createAllocateInventoryOrder(options, manager = this.dataSource.manager) {
+        const repos = this.getRepositories(manager);
+        const key = await this.helperService.getSeq(this.seqPrefix);
+        const { items, ...orderOptions } = options;
+        const order = await repos.allocateInventoryOrder.save(repos.allocateInventoryOrder.create({
+            key,
+            ...orderOptions,
+        }));
+        if (items?.length) {
+            const processedItems = items.map((item) => ({
+                ...item,
+                orderId: order.id,
+            }));
+            await this.processAllocateInventoryOrderItems(processedItems, manager);
+        }
+        return order;
+    }
+    async updateAllocateInventoryOrder({ id, manager = this.dataSource.manager, ...options }) {
+        const repos = this.getRepositories(manager);
+        const { items, ...orderOptions } = options;
+        const order = await repos.allocateInventoryOrder.findOneBy({ id });
+        const updated = await repos.allocateInventoryOrder.save({
+            ...order,
+            ...orderOptions,
+        });
+        if (items?.length) {
+            const existingItemIds = new Set((await repos.allocateInventoryOrderItem.find({
+                where: { orderId: id },
+                relations: ['changes'],
+            })).map((item) => item.id));
+            const newItems = [];
+            const existingItems = [];
+            items.forEach((item) => {
+                if (!item.id)
+                    newItems.push({ ...item, orderId: id });
+                else if (existingItemIds.has(item.id))
+                    existingItems.push({ ...item, orderId: id });
+            });
+            if (newItems.length)
+                await this.processAllocateInventoryOrderItems(newItems, manager);
+            if (existingItems.length)
+                await repos.allocateInventoryOrderItem.save(await Promise.all(existingItems.map((item) => repos.allocateInventoryOrderItem.create(item))));
+        }
+        return updated;
+    }
+    async deallocate(options, manager = this.dataSource.manager) {
+        if (!Array.isArray(options))
+            options = [options];
+        const repos = this.getRepositories(manager);
+        const key = await this.helperService.getSeq(this.seqPrefix, manager);
+        const order = await repos.allocateInventoryOrder.save(repos.allocateInventoryOrder.create({ key }));
+        if (options.length > 0) {
+            await Promise.all(options.map(async (data) => {
+                // Ensure required fields are present
+                if (!data.batchId || !data.materialId)
+                    return;
+                const originalBatch = await this.batchService.batchRepository.findOneByOrFail({
+                    id: data.batchId,
+                    saleId: Not(IsNull()),
+                    saleSerialId: Not(IsNull()),
+                });
+                const splittedBatch = await this.batchService.splitBatch({
+                    id: data.batchId,
+                    saleId: null, // mark splitted batch with null saleId to indicate deallocation
+                    saleSerialId: null,
+                    manager,
+                });
+                // Save item with ORIGINAL batch id to maintain source state
+                const item = await repos.allocateInventoryOrderItem.save(repos.allocateInventoryOrderItem.create({
+                    ...data,
+                    saleId: originalBatch.saleId,
+                    saleSerialId: originalBatch.saleSerialId,
+                    targetAllocatedQuantity: -1 * data.quantity,
+                    orderId: order.id,
+                }));
+                const base = await repos.order.save({});
+                const conversionFactor = await this.materialService.getConversionFactor(item.materialId, item.unitId || undefined);
+                const change = await repos.allocateInventoryOrderChange.save(repos.allocateInventoryOrderChange.create({
+                    itemId: item.id,
+                    id: base.id,
+                    quantityChanged: -1 * item.targetAllocatedQuantity * conversionFactor,
+                }));
+                // Stock movements track the hold 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: change.quantityChanged,
+                }, manager);
+                await repos.stock.save(repos.stock.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 * change.quantityChanged,
+                    },
+                    // add to splitted batch in released state
+                    {
+                        orderId: base.id,
+                        materialId: item.materialId,
+                        batchId: splittedBatch.id, // splitted batch marked deallocated with null saleId
+                        locationId: this.stockService.resolveLocationId(item.locationId),
+                        loaderId: this.stockService.resolveLoaderId(item.loaderId),
+                        quantity: change.quantityChanged,
+                    },
+                ]));
+            }));
+        }
+        return order;
+    }
+    findMany(options) {
+        const queryBuilder = this.dataSource
+            .getRepository(this.allocateInventoryOrderEntity)
+            .createQueryBuilder('to');
+        if (options.key)
+            queryBuilder.andWhere('to.key ILIKE :key', { key: `%${options.key}%` });
+        if (options.dateRange)
+            queryBuilder.andWhere('to.createdAt BETWEEN :start AND :end', {
+                start: options.dateRange.from,
+                end: options.dateRange.to,
+            });
+        if (options.materialId)
+            queryBuilder.innerJoin('to.items', 'm_items', 'm_items.materialId = :materialId', {
+                materialId: options.materialId,
+            });
+        if (options.batchId)
+            queryBuilder.innerJoin('to.items', 'b_items', 'b_items.batchId = :batchId', {
+                batchId: options.batchId,
+            });
+        if (options.locationId)
+            queryBuilder.innerJoin('to.items', 'l_items', 'l_items.locationId = :locationId', {
+                locationId: options.locationId,
+            });
+        if (options.loaderId)
+            queryBuilder.innerJoin('to.items', 'ld_items', 'ld_items.loaderId = :loaderId', {
+                loaderId: options.loaderId,
+            });
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+};
+AllocateInventoryOrderService = __decorate([
+    Injectable(),
+    __param(5, Inject(AllocateInventoryOrderEntity)),
+    __param(6, Inject(AllocateInventoryOrderItemEntity)),
+    __param(7, Inject(StockEntity)),
+    __metadata("design:paramtypes", [DataSource,
+        HelperService,
+        MaterialService,
+        BatchService,
+        StockService, Object, Object, Object])
+], AllocateInventoryOrderService);
+
+export { AllocateInventoryOrderService };

package/lib/services/base-order.service.d.ts

@@ -0,0 +1,41 @@
+import { Repository } from 'typeorm';
+import { StockEntityClass } from '../models';
+import { OrderEntity } from '@rytass/wms-base-nestjs-module';
+import { MaterialService } from './material.service';
+import { StockService } from './stock.service';
+export interface StockEntryParams {
+    materialId: string;
+    batchId: string;
+    quantity: number;
+    locationId?: string;
+    loaderId?: string;
+    unitId?: string;
+}
+export interface Repositories {
+    order: Repository<OrderEntity>;
+    stock: Repository<StockEntityClass>;
+    [key: string]: Repository<any>;
+}
+/**
+ * Base service for order operations that create/deduct stock entries.
+ * Provides common methods for adding and deducting inventory across different order types.
+ */
+export declare abstract class BaseOrderService {
+    protected abstract materialService: MaterialService;
+    protected abstract stockService: StockService;
+    /**
+     * Creates a new order and saves a positive quantity stock entry
+     * @param repos Repository map containing order and stock repositories
+     * @param params Stock entry parameters (materialId, batchId, quantity, locationId?, loaderId?, unitId?)
+     * @returns Created order ID
+     */
+    protected add(repos: Repositories, params: StockEntryParams): Promise<string>;
+    /**
+     * Creates a negative quantity stock entry linked to a source order
+     * Used to deduct stock from an existing status (FREE, ALLOCATED, IN_TRANSFER, etc.)
+     * @param repos Repository map containing order and stock repositories
+     * @param sourceOrderId The order ID to link the deduction to (typically an existing allocated/transferred order)
+     * @param params Stock entry parameters (materialId, batchId, quantity, locationId?, loaderId?, unitId?)
+     */
+    protected deduct(repos: Repositories, params: StockEntryParams): Promise<void>;
+}

package/lib/services/batch.service.d.ts

@@ -0,0 +1,30 @@
+import { DataSource, EntityManager, EntityTarget, Repository } from 'typeorm';
+import { BatchEntityClass } from '../models';
+import { FindBatchInput } from '../typings/find-batch.input';
+import { GetBatchInput, SplitBatchInput } from '../typings/get-batch.input';
+import { BatchGroupEntityClass } from '../models/metadata/batch-group.entity';
+export declare class BatchService<T extends BatchEntityClass = BatchEntityClass> {
+    private readonly dataSource;
+    readonly batchEntity: EntityTarget<T>;
+    readonly batchGroupEntity: EntityTarget<BatchGroupEntityClass>;
+    readonly batchRepository: Repository<T>;
+    readonly batchGroupRepository: Repository<BatchGroupEntityClass>;
+    constructor(dataSource: DataSource, batchEntity: EntityTarget<T>, batchGroupEntity: EntityTarget<BatchGroupEntityClass>);
+    /**
+     * Validates batch state transition based on hierarchy:
+     * inShipment = held = transferId = vendorId = customerId > saleId+saleSerialId > inspectionResult
+     *
+     * - Top tier (terminal): inShipment, held, transferId, vendorId, customerId → no state change allowed
+     * - Middle tier: saleId+saleSerialId → can only go UP to top tier
+     * - Bottom tier: inspectionResult → can go UP to middle or top tier, but cannot change inspectionResult
+     */
+    private validateStateTransition;
+    getBatch({ manager, ...options }: GetBatchInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    splitBatch({ manager, ...options }: {
+        id: string;
+        manager?: EntityManager;
+    } & SplitBatchInput): Promise<BatchEntityClass>;
+    findMany(options: FindBatchInput<T>): Promise<[BatchGroupEntityClass[], number]>;
+}

package/lib/services/batch.service.js

@@ -0,0 +1,218 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import { Injectable, Inject } from '@nestjs/common';
+import { DataSource, IsNull } from 'typeorm';
+import { BatchEntity, BatchEntityClass } from '../models/metadata/batch.entity.js';
+import { BatchGroupEntity } from '../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 '../models/metadata/material.entity.js';
+import '../models/metadata/material-unit.entity.js';
+import '../models/metadata/sale-order.entity.js';
+import '../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 '../models/extensions/ship-inventory-order/ship-inventory-order-item.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order.entity.js';
+import '../models/extensions/ship-inventory-order/ship-inventory-order-reference.entity.js';
+import '../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';
+
+let BatchService = class BatchService {
+    dataSource;
+    batchEntity;
+    batchGroupEntity;
+    batchRepository;
+    batchGroupRepository;
+    constructor(dataSource, batchEntity, batchGroupEntity) {
+        this.dataSource = dataSource;
+        this.batchEntity = batchEntity;
+        this.batchGroupEntity = batchGroupEntity;
+        this.batchRepository = this.dataSource.getRepository(this.batchEntity);
+        this.batchGroupRepository =
+            this.dataSource.getRepository(this.batchGroupEntity);
+    }
+    /**
+     * Validates batch state transition based on hierarchy:
+     * inShipment = held = transferId = vendorId = customerId > saleId+saleSerialId > inspectionResult
+     *
+     * - Top tier (terminal): inShipment, held, transferId, vendorId, customerId → no state change allowed
+     * - Middle tier: saleId+saleSerialId → can only go UP to top tier
+     * - Bottom tier: inspectionResult → can go UP to middle or top tier, but cannot change inspectionResult
+     */
+    validateStateTransition(batch, options) {
+        // Check if trying to clear/release a top-tier state
+        const isReleasingInShipment = batch.inShipment === true && options.inShipment === false;
+        const isReleasingHeld = batch.held === true && options.held === false;
+        const isReleasingTransfer = batch.transferId != null && options.transferId === null;
+        const isReleasingVendor = batch.vendorId != null && options.vendorId === null;
+        const isReleasingCustomer = batch.customerId != null && options.customerId === null;
+        const isReleasing = isReleasingInShipment ||
+            isReleasingHeld ||
+            isReleasingTransfer ||
+            isReleasingVendor ||
+            isReleasingCustomer;
+        // Determine current state tier
+        const isTopTier = batch.inShipment === true ||
+            batch.held === true ||
+            batch.transferId != null ||
+            batch.vendorId != null ||
+            batch.customerId != null;
+        const isMiddleTier = batch.saleId != null || batch.saleSerialId != null;
+        // What is being changed (explicitly set, not undefined)
+        const changingMiddleTier = options.saleId !== undefined || options.saleSerialId !== undefined;
+        const changingInspection = options.inspectionResult !== undefined;
+        // Rule 1: Top tier is terminal unless explicitly releasing that state
+        if (isTopTier && !isReleasing) {
+            const state = batch.inShipment
+                ? 'in shipment'
+                : batch.held
+                    ? 'held'
+                    : batch.transferId
+                        ? 'in transfer'
+                        : batch.vendorId
+                            ? 'vendor inventory'
+                            : 'customer inventory';
+            throw new Error(`Batch is ${state}, cannot transition to other states. Only release is allowed.`);
+        }
+        // Rule 2: Middle tier cannot change to same tier
+        if (isMiddleTier && changingMiddleTier) {
+            throw new Error('Cannot modify allocation (saleId/saleSerialId) for already allocated batch');
+        }
+        // Rule 3: Cannot change inspection result after it's set (unless releasing to higher tier)
+        if (batch.inspectionResult != null &&
+            !isMiddleTier &&
+            !isTopTier &&
+            changingInspection) {
+            throw new Error('Inspection result already set, cannot modify');
+        }
+    }
+    async getBatch({ manager = this.dataSource.manager, ...options }) {
+        const batchRepository = manager.getRepository(BatchEntityClass);
+        const batchGroupRepository = manager.getRepository(this.batchGroupEntity);
+        const unsplittedCondition = {
+            saleId: IsNull(),
+            saleSerialId: IsNull(),
+            customerId: IsNull(),
+            vendorId: IsNull(),
+            transferId: IsNull(),
+            inspectionResult: IsNull(),
+            held: false,
+            inShipment: false,
+        };
+        const existed = await batchRepository.findOneBy({
+            ...unsplittedCondition,
+            key: options.key,
+            materialId: options.materialId,
+        });
+        if (existed)
+            return existed;
+        const batchGroup = await batchGroupRepository.save(batchGroupRepository.create({
+            key: options.key,
+            materialId: options.materialId,
+        }));
+        const batch = await batchRepository.save(batchRepository.create({
+            ...options,
+            groupId: batchGroup.id,
+        }));
+        return batch;
+    }
+    async splitBatch({ manager = this.dataSource.manager, ...options }) {
+        const batchRepository = manager.getRepository(BatchEntityClass);
+        const batch = await batchRepository.findOneOrFail({
+            where: { id: options.id },
+            relations: ['batchGroup'],
+        });
+        // Validate state transition before proceeding
+        this.validateStateTransition(batch, options);
+        // Create merged batch object with new metrics
+        const mergedBatch = {
+            ...batch,
+            ...options,
+            groupId: batch.batchGroup.id,
+        };
+        // Build where condition dynamically to handle optional fields
+        const whereCondition = {
+            groupId: mergedBatch.groupId,
+            saleId: mergedBatch.saleId ?? null,
+            saleSerialId: mergedBatch.saleSerialId ?? null,
+            customerId: mergedBatch.customerId ?? null,
+            vendorId: mergedBatch.vendorId ?? null,
+            inspectionResult: mergedBatch.inspectionResult ?? null,
+            transferId: mergedBatch.transferId ?? null,
+            held: mergedBatch.held ?? false,
+            inShipment: mergedBatch.inShipment ?? false,
+        };
+        // Check if a batch with these exact metrics already exists in the same group
+        const existingBatch = await batchRepository.findOne({
+            where: whereCondition,
+        });
+        if (existingBatch) {
+            return existingBatch;
+        }
+        // If no matching batch exists, create a new one
+        return batchRepository.save(batchRepository.create({
+            ...mergedBatch,
+            key: `${batch.batchGroup.key}_${Date.now().toString()}`,
+            id: undefined,
+        }));
+    }
+    async findMany(options) {
+        const queryBuilder = this.batchGroupRepository.createQueryBuilder('batch');
+        if (options.wildcard) {
+            const { key, value } = options.wildcard;
+            queryBuilder.andWhere(`batch."${String(key)}" ILIKE :value`, {
+                value: `%${value}%`,
+            });
+        }
+        if (options.materialId)
+            queryBuilder.andWhere('batch."materialId" = :materialId', {
+                materialId: options.materialId,
+            });
+        if (options.offset !== undefined && options.offset >= 0)
+            queryBuilder.skip(options.offset);
+        if (options.limit !== undefined && options.limit > 0)
+            queryBuilder.take(options.limit);
+        return queryBuilder.getManyAndCount();
+    }
+};
+BatchService = __decorate([
+    Injectable(),
+    __param(1, Inject(BatchEntity)),
+    __param(2, Inject(BatchGroupEntity)),
+    __metadata("design:paramtypes", [DataSource, Object, Object])
+], BatchService);
+
+export { BatchService };

package/lib/services/helper.service.d.ts

@@ -0,0 +1,6 @@
+import { DataSource } from 'typeorm';
+export declare class HelperService {
+    private readonly dataSource;
+    constructor(dataSource: DataSource);
+    getSeq(prefix: string, manager?: import("typeorm").EntityManager): Promise<string>;
+}

package/lib/services/helper.service.js

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from 'tslib';
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { DateTime } from 'luxon';
+
+let HelperService = class HelperService {
+    dataSource;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+    }
+    async getSeq(prefix, manager = this.dataSource.manager) {
+        const dateStr = DateTime.now().toFormat('yyyyMMdd');
+        const seqName = `${prefix}_${dateStr}`;
+        const quotedSeqName = `"${seqName}"`;
+        await this.dataSource.query(`CREATE SEQUENCE IF NOT EXISTS ${quotedSeqName} START 1`);
+        const [{ seq_num }] = await manager.query(`SELECT nextval($1) as seq_num`, [
+            `"${seqName}"`,
+        ]);
+        const serialNumber = String(seq_num).padStart(4, '0');
+        return `${dateStr}${serialNumber}`;
+    }
+};
+HelperService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DataSource])
+], HelperService);
+
+export { HelperService };

package/lib/services/hold-inventory-order.service.d.ts

@@ -0,0 +1,29 @@
+import { HoldInventoryOrderEntityClass, HoldInventoryOrderItemEntityClass, StockEntityClass } from '../models';
+import { DataSource, EntityManager, EntityTarget } from 'typeorm';
+import { HelperService } from './helper.service';
+import { CreateHoldInventoryOrderInput, UpdateHoldInventoryOrderInput } from '../typings/create-hold-inventory-order.input';
+import { FindHoldInventoryOrderInput } from '../typings/find-hold-inventory-order.input';
+import { ReleaseInventoryOrderItemInput } from '../typings/release-inventory-order.input';
+import { MaterialService } from './material.service';
+import { BatchService } from './batch.service';
+import { StockService } from './stock.service';
+export declare class HoldInventoryOrderService<T extends HoldInventoryOrderEntityClass = HoldInventoryOrderEntityClass, K extends HoldInventoryOrderItemEntityClass = HoldInventoryOrderItemEntityClass> {
+    private readonly dataSource;
+    private readonly helperService;
+    private readonly materialService;
+    private readonly batchService;
+    private readonly stockService;
+    readonly holdInventoryOrderEntity: EntityTarget<T>;
+    readonly holdInventoryOrderItemEntity: EntityTarget<K>;
+    readonly stockEntity: EntityTarget<StockEntityClass>;
+    private readonly seqPrefix;
+    constructor(dataSource: DataSource, helperService: HelperService, materialService: MaterialService, batchService: BatchService, stockService: StockService, holdInventoryOrderEntity: EntityTarget<T>, holdInventoryOrderItemEntity: EntityTarget<K>, stockEntity: EntityTarget<StockEntityClass>);
+    private getRepositories;
+    private processHoldInventoryOrderItems;
+    createHoldInventoryOrder(options: CreateHoldInventoryOrderInput, manager?: EntityManager): Promise<T>;
+    updateHoldInventoryOrder({ id, manager, ...options }: UpdateHoldInventoryOrderInput & {
+        manager?: EntityManager;
+    }): Promise<T>;
+    findMany(options: FindHoldInventoryOrderInput): Promise<[T[], number]>;
+    release(options: ReleaseInventoryOrderItemInput | ReleaseInventoryOrderItemInput[], manager?: EntityManager): Promise<T>;
+}